From 38a5659a2f4e6ea556675167d00db4756fa55a31 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 12:28:59 -0300 Subject: [PATCH 01/41] fix: add a `remove_unreachable_instructions` SSA pass --- compiler/noirc_evaluator/src/ssa.rs | 2 + compiler/noirc_evaluator/src/ssa/opt/mod.rs | 1 + .../opt/remove_unreachable_instructions.rs | 159 ++++++++++++++++++ 3 files changed, 162 insertions(+) create mode 100644 compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs index 41251b8865d..aa1c498b387 100644 --- a/compiler/noirc_evaluator/src/ssa.rs +++ b/compiler/noirc_evaluator/src/ssa.rs @@ -219,6 +219,7 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { Ssa::verify_no_dynamic_indices_to_references, "Verifying no dynamic array indices to reference value elements", ), + SsaPass::new(Ssa::remove_unreachable_instructions, "Remove unreachable instructions"), ] } @@ -232,6 +233,7 @@ pub fn secondary_passes(brillig: &Brillig) -> Vec { // In that case it's unused so we can remove it. This is what we check next. SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), SsaPass::new(Ssa::dead_instruction_elimination_acir, "Dead Instruction Elimination - ACIR"), + SsaPass::new(Ssa::remove_unreachable_instructions, "Remove unreachable instructions"), ] } diff --git a/compiler/noirc_evaluator/src/ssa/opt/mod.rs b/compiler/noirc_evaluator/src/ssa/opt/mod.rs index d5f8386d990..3b4740fc222 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/mod.rs @@ -31,6 +31,7 @@ mod remove_enable_side_effects; mod remove_if_else; mod remove_truncate_after_range_check; mod remove_unreachable; +mod remove_unreachable_instructions; mod simple_optimization; mod simplify_cfg; mod unrolling; diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs new file mode 100644 index 00000000000..845c58bf991 --- /dev/null +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -0,0 +1,159 @@ +//! This module defines an SSA pass to remove instructions that are unreachable. +//! For example, if an instruction in a block is `constrain u1 0 == u1 1`, +//! any subsequent instructions in that block will never be executed. This pass +//! then removes those subsequent instructions and replaces the block's terminator +//! values with zeroed values of the appropriate type. +use std::sync::Arc; + +use acvm::{AcirField, FieldElement}; +use noirc_errors::call_stack::CallStackId; + +use crate::ssa::{ + ir::{ + basic_block::BasicBlockId, function::Function, instruction::Instruction, types::Type, + value::ValueId, + }, + ssa_gen::Ssa, +}; + +impl Ssa { + pub(crate) fn remove_unreachable_instructions(mut self) -> Ssa { + for function in self.functions.values_mut() { + function.remove_unreachable_instructions(); + } + self + } +} + +impl Function { + fn remove_unreachable_instructions(&mut self) { + let mut current_block_id = None; + let mut current_block_instructions_are_unreachable = false; + let mut blocks_with_unreachable_terminators = Vec::new(); + + self.simple_reachable_blocks_optimization(|context| { + let block_id = context.block_id; + + if current_block_id.is_none() { + current_block_id = Some(block_id); + } else if current_block_id != Some(block_id) { + current_block_instructions_are_unreachable = false; + current_block_id = Some(block_id); + } + + if current_block_instructions_are_unreachable { + context.remove_current_instruction(); + } + + let instruction = context.instruction(); + match instruction { + Instruction::Constrain(lhs, rhs, _) => { + let Some(lhs_constant) = context.dfg.get_numeric_constant(*lhs) else { + return; + }; + let Some(rhs_constant) = context.dfg.get_numeric_constant(*rhs) else { + return; + }; + if lhs_constant != rhs_constant { + current_block_instructions_are_unreachable = true; + blocks_with_unreachable_terminators.push(block_id); + } + } + Instruction::ConstrainNotEqual(lhs, rhs, _) => { + let Some(lhs_constant) = context.dfg.get_numeric_constant(*lhs) else { + return; + }; + let Some(rhs_constant) = context.dfg.get_numeric_constant(*rhs) else { + return; + }; + if lhs_constant == rhs_constant { + current_block_instructions_are_unreachable = true; + blocks_with_unreachable_terminators.push(block_id); + } + } + _ => (), + } + }); + + for block_id in blocks_with_unreachable_terminators { + let mut terminator = self.dfg[block_id].take_terminator(); + terminator.map_values_mut(|value_id| { + let typ = self.dfg.type_of_value(value_id); + zeroed_value(self, block_id, &typ) + }); + self.dfg[block_id].set_terminator(terminator); + } + } +} + +fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> ValueId { + match typ { + Type::Numeric(numeric_type) => { + function.dfg.make_constant(FieldElement::zero(), *numeric_type) + } + Type::Array(element_types, len) => { + let mut array = im::Vector::new(); + for _ in 0..*len { + for typ in element_types.iter() { + array.push_back(zeroed_value(function, block_id, typ)); + } + } + let instruction = Instruction::MakeArray { elements: array, typ: typ.clone() }; + let stack = CallStackId::root(); + function.dfg.insert_instruction_and_results(instruction, block_id, None, stack).first() + } + Type::Slice(_) => { + let array = im::Vector::new(); + let instruction = Instruction::MakeArray { elements: array, typ: typ.clone() }; + let stack = CallStackId::root(); + function.dfg.insert_instruction_and_results(instruction, block_id, None, stack).first() + } + Type::Reference(element_type) => { + let instruction = Instruction::Allocate; + let reference_type = Type::Reference(Arc::new((**element_type).clone())); + function + .dfg + .insert_instruction_and_results( + instruction, + block_id, + Some(vec![reference_type]), + CallStackId::root(), + ) + .first() + } + Type::Function => { + // We can have the function return itself. It's fine because the terminator is unreachable anyway. + function.dfg.import_function(function.id()) + } + } +} + +#[cfg(test)] +mod test { + use crate::{assert_ssa_snapshot, ssa::ssa_gen::Ssa}; + + #[test] + fn removes_unreachable_instructions() { + let src = r#" + acir(inline) predicate_pure fn main f0 { + b0(): + v0 = make_array [] : [&mut u1; 0] + constrain u1 0 == u1 1, "Index out of bounds" + v4 = array_get v0, index u32 0 -> &mut u1 + v5 = load v4 -> u1 + return v5 + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + v0 = make_array [] : [&mut u1; 0] + constrain u1 0 == u1 1, "Index out of bounds" + return u1 0 + } + "#); + } +} From 2702a7d75cf25df7a1bed16a1eb99e0ca1542c42 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 12:29:12 -0300 Subject: [PATCH 02/41] Add a regression test --- .../compile_success_with_bug/regression_8774/Nargo.toml | 6 ++++++ .../compile_success_with_bug/regression_8774/src/main.nr | 4 ++++ .../regression_8774/execute__tests__expanded.snap | 8 ++++++++ 3 files changed, 18 insertions(+) create mode 100644 test_programs/compile_success_with_bug/regression_8774/Nargo.toml create mode 100644 test_programs/compile_success_with_bug/regression_8774/src/main.nr create mode 100644 tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8774/execute__tests__expanded.snap diff --git a/test_programs/compile_success_with_bug/regression_8774/Nargo.toml b/test_programs/compile_success_with_bug/regression_8774/Nargo.toml new file mode 100644 index 00000000000..63cce813945 --- /dev/null +++ b/test_programs/compile_success_with_bug/regression_8774/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "regression_8774" +type = "bin" +authors = [""] + +[dependencies] diff --git a/test_programs/compile_success_with_bug/regression_8774/src/main.nr b/test_programs/compile_success_with_bug/regression_8774/src/main.nr new file mode 100644 index 00000000000..afa6fff2787 --- /dev/null +++ b/test_programs/compile_success_with_bug/regression_8774/src/main.nr @@ -0,0 +1,4 @@ +fn main() -> pub bool { + let d: [&mut bool; 0] = []; + *d[0] +} diff --git a/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8774/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8774/execute__tests__expanded.snap new file mode 100644 index 00000000000..5ad25880005 --- /dev/null +++ b/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8774/execute__tests__expanded.snap @@ -0,0 +1,8 @@ +--- +source: tooling/nargo_cli/tests/execute.rs +expression: expanded_code +--- +fn main() -> pub bool { + let d: [&mut bool; 0] = []; + *d[0] +} From 1f59a54d231ca2aad65523656ec412d002c304dc Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 12:56:48 -0300 Subject: [PATCH 03/41] Run it before removing unreachable functions --- compiler/noirc_evaluator/src/ssa.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs index aa1c498b387..45eb2785634 100644 --- a/compiler/noirc_evaluator/src/ssa.rs +++ b/compiler/noirc_evaluator/src/ssa.rs @@ -212,6 +212,7 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { SsaPass::new(Ssa::brillig_array_get_and_set, "Brillig Array Get and Set Optimizations"), // Perform another DIE pass to update the used globals after offsetting Brillig indexes. SsaPass::new(Ssa::dead_instruction_elimination, "Dead Instruction Elimination"), + SsaPass::new(Ssa::remove_unreachable_instructions, "Remove unreachable instructions"), // A function can be potentially unreachable post-DIE if all calls to that function were removed. SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), SsaPass::new(Ssa::checked_to_unchecked, "Checked to unchecked"), @@ -219,7 +220,6 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { Ssa::verify_no_dynamic_indices_to_references, "Verifying no dynamic array indices to reference value elements", ), - SsaPass::new(Ssa::remove_unreachable_instructions, "Remove unreachable instructions"), ] } @@ -229,11 +229,11 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { pub fn secondary_passes(brillig: &Brillig) -> Vec { vec![ SsaPass::new(move |ssa| ssa.fold_constants_with_brillig(brillig), "Inlining Brillig Calls"), + SsaPass::new(Ssa::remove_unreachable_instructions, "Remove unreachable instructions"), // It could happen that we inlined all calls to a given brillig function. // In that case it's unused so we can remove it. This is what we check next. SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), SsaPass::new(Ssa::dead_instruction_elimination_acir, "Dead Instruction Elimination - ACIR"), - SsaPass::new(Ssa::remove_unreachable_instructions, "Remove unreachable instructions"), ] } From d336b7d70ddb647c317fe9a2953e5fae22d1d9f3 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 13:06:45 -0300 Subject: [PATCH 04/41] Slightly improve pass name --- compiler/noirc_evaluator/src/ssa.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs index 45eb2785634..dd9f8b74464 100644 --- a/compiler/noirc_evaluator/src/ssa.rs +++ b/compiler/noirc_evaluator/src/ssa.rs @@ -212,7 +212,7 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { SsaPass::new(Ssa::brillig_array_get_and_set, "Brillig Array Get and Set Optimizations"), // Perform another DIE pass to update the used globals after offsetting Brillig indexes. SsaPass::new(Ssa::dead_instruction_elimination, "Dead Instruction Elimination"), - SsaPass::new(Ssa::remove_unreachable_instructions, "Remove unreachable instructions"), + SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), // A function can be potentially unreachable post-DIE if all calls to that function were removed. SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), SsaPass::new(Ssa::checked_to_unchecked, "Checked to unchecked"), @@ -229,7 +229,7 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { pub fn secondary_passes(brillig: &Brillig) -> Vec { vec![ SsaPass::new(move |ssa| ssa.fold_constants_with_brillig(brillig), "Inlining Brillig Calls"), - SsaPass::new(Ssa::remove_unreachable_instructions, "Remove unreachable instructions"), + SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), // It could happen that we inlined all calls to a given brillig function. // In that case it's unused so we can remove it. This is what we check next. SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), From 1d80bd8f43f397f14cf5dae04955852f1bdd2360 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 13:07:02 -0300 Subject: [PATCH 05/41] Simplify logic --- .../src/ssa/opt/remove_unreachable_instructions.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 845c58bf991..9c88502e01e 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -34,13 +34,12 @@ impl Function { self.simple_reachable_blocks_optimization(|context| { let block_id = context.block_id; - if current_block_id.is_none() { - current_block_id = Some(block_id); - } else if current_block_id != Some(block_id) { + if current_block_id != Some(block_id) { current_block_instructions_are_unreachable = false; - current_block_id = Some(block_id); } + current_block_id = Some(block_id); + if current_block_instructions_are_unreachable { context.remove_current_instruction(); } From ea2378d734922459ff542edc626fa74a4858a97c Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 14:31:56 -0300 Subject: [PATCH 06/41] If a block is unreachable, its successors are too --- .../opt/remove_unreachable_instructions.rs | 122 +++++++++++++++--- 1 file changed, 102 insertions(+), 20 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 9c88502e01e..7bdb3ed304a 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -2,16 +2,19 @@ //! For example, if an instruction in a block is `constrain u1 0 == u1 1`, //! any subsequent instructions in that block will never be executed. This pass //! then removes those subsequent instructions and replaces the block's terminator -//! values with zeroed values of the appropriate type. +//! values with zeroed values of the appropriate type. If the block has successors +//! whose predecessors are that block only, those successors will also be unreachable +//! so the same treatment is applied to them. use std::sync::Arc; use acvm::{AcirField, FieldElement}; +use fxhash::FxHashSet as HashSet; use noirc_errors::call_stack::CallStackId; use crate::ssa::{ ir::{ - basic_block::BasicBlockId, function::Function, instruction::Instruction, types::Type, - value::ValueId, + basic_block::BasicBlockId, cfg::ControlFlowGraph, function::Function, + instruction::Instruction, types::Type, value::ValueId, }, ssa_gen::Ssa, }; @@ -27,25 +30,31 @@ impl Ssa { impl Function { fn remove_unreachable_instructions(&mut self) { + let cfg = ControlFlowGraph::with_function(self); + let mut current_block_id = None; let mut current_block_instructions_are_unreachable = false; - let mut blocks_with_unreachable_terminators = Vec::new(); + let mut unreachable_blocks = HashSet::default(); self.simple_reachable_blocks_optimization(|context| { let block_id = context.block_id; if current_block_id != Some(block_id) { - current_block_instructions_are_unreachable = false; - } + current_block_id = Some(block_id); + current_block_instructions_are_unreachable = unreachable_blocks.contains(&block_id); - current_block_id = Some(block_id); + if current_block_instructions_are_unreachable { + add_successors(block_id, &cfg, &mut unreachable_blocks); + } + } if current_block_instructions_are_unreachable { context.remove_current_instruction(); + return; } let instruction = context.instruction(); - match instruction { + let is_unreachable = match instruction { Instruction::Constrain(lhs, rhs, _) => { let Some(lhs_constant) = context.dfg.get_numeric_constant(*lhs) else { return; @@ -53,10 +62,7 @@ impl Function { let Some(rhs_constant) = context.dfg.get_numeric_constant(*rhs) else { return; }; - if lhs_constant != rhs_constant { - current_block_instructions_are_unreachable = true; - blocks_with_unreachable_terminators.push(block_id); - } + lhs_constant != rhs_constant } Instruction::ConstrainNotEqual(lhs, rhs, _) => { let Some(lhs_constant) = context.dfg.get_numeric_constant(*lhs) else { @@ -65,16 +71,20 @@ impl Function { let Some(rhs_constant) = context.dfg.get_numeric_constant(*rhs) else { return; }; - if lhs_constant == rhs_constant { - current_block_instructions_are_unreachable = true; - blocks_with_unreachable_terminators.push(block_id); - } + lhs_constant == rhs_constant } - _ => (), + _ => false, + }; + + if is_unreachable { + current_block_instructions_are_unreachable = true; + unreachable_blocks.insert(block_id); + + add_successors(block_id, &cfg, &mut unreachable_blocks); } }); - for block_id in blocks_with_unreachable_terminators { + for block_id in unreachable_blocks { let mut terminator = self.dfg[block_id].take_terminator(); terminator.map_values_mut(|value_id| { let typ = self.dfg.type_of_value(value_id); @@ -85,6 +95,21 @@ impl Function { } } +/// Adds all of a block's successors to the `blocks` set, if each of those successors +/// have the given block as their only predecessor. +fn add_successors( + block_id: BasicBlockId, + cfg: &ControlFlowGraph, + blocks: &mut HashSet, +) { + for successor in cfg.successors(block_id) { + let successor_predecessors = cfg.predecessors(successor).collect::>(); + if successor_predecessors.len() == 1 && successor_predecessors[0] == block_id { + blocks.insert(successor); + } + } +} + fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> ValueId { match typ { Type::Numeric(numeric_type) => { @@ -129,10 +154,13 @@ fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> #[cfg(test)] mod test { - use crate::{assert_ssa_snapshot, ssa::ssa_gen::Ssa}; + use crate::{ + assert_ssa_snapshot, + ssa::{opt::assert_normalized_ssa_equals, ssa_gen::Ssa}, + }; #[test] - fn removes_unreachable_instructions() { + fn removes_unreachable_instructions_in_block() { let src = r#" acir(inline) predicate_pure fn main f0 { b0(): @@ -155,4 +183,58 @@ mod test { } "#); } + + #[test] + fn removes_unreachable_instructions_from_successors() { + let src = r#" + acir(inline) predicate_pure fn main f0 { + b0(): + v0 = make_array [] : [&mut u1; 0] + constrain u1 0 == u1 1, "Index out of bounds" + v4 = array_get v0, index u32 0 -> &mut u1 + v5 = load v4 -> u1 + jmp b1(v5) + b1(v6: u1): + v7 = add v6, u1 1 + jmp b2(v7) + b2(v8: u1): + v9 = add v8, u1 1 + return v9 + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + v2 = make_array [] : [&mut u1; 0] + constrain u1 0 == u1 1, "Index out of bounds" + jmp b1(u1 0) + b1(v0: u1): + jmp b2(u1 0) + b2(v1: u1): + return u1 0 + } + "#); + } + + #[test] + fn does_not_remove_unreachable_instructions_from_successor_if_they_have_other_predecessors() { + let src = r#" + acir(inline) predicate_pure fn main f0 { + b0(): + jmpif u1 0 then: b1, else: b2 + b1(): + constrain u1 0 == u1 1, "Index out of bounds" + jmp b2() + b2(): + v1 = add Field 1, Field 2 + return v1 + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(); + assert_normalized_ssa_equals(ssa, src); + } } From 36902d8d36fed80466011164c9290a3d7653f659 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 14:38:39 -0300 Subject: [PATCH 07/41] Traverse blocks in pre-order --- .../noirc_evaluator/src/ssa/ir/function.rs | 20 +++++++++- .../opt/remove_unreachable_instructions.rs | 37 ++++++++++++++++++- .../src/ssa/opt/simple_optimization.rs | 27 +++++++++++++- 3 files changed, 80 insertions(+), 4 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/function.rs b/compiler/noirc_evaluator/src/ssa/ir/function.rs index b6c4296b561..7c03b950c65 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/function.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/function.rs @@ -1,7 +1,8 @@ -use std::collections::BTreeSet; +use std::collections::{BTreeSet, VecDeque}; use std::sync::Arc; use acvm::FieldElement; +use fxhash::FxHashSet as HashSet; use iter_extended::vecmap; use noirc_frontend::monomorphization::ast::InlineType; use serde::{Deserialize, Serialize}; @@ -192,6 +193,23 @@ impl Function { blocks } + /// Collects all the reachable blocks of this function and returns them in pre-order. + pub(crate) fn reachable_pre_order_blocks(&self) -> Vec { + let mut blocks = Vec::new(); + let mut seen = HashSet::default(); + let mut stack = VecDeque::new(); + stack.push_back(self.entry_block); + + while let Some(block) = stack.pop_front() { + if seen.insert(block) { + blocks.push(block); + stack.extend(self.dfg[block].successors()); + } + } + + blocks + } + pub(crate) fn signature(&self) -> Signature { let params = vecmap(self.parameters(), |param| self.dfg.type_of_value(*param)); let returns = vecmap(self.returns(), |ret| self.dfg.type_of_value(*ret)); diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 7bdb3ed304a..93aeecf7b1a 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -36,7 +36,7 @@ impl Function { let mut current_block_instructions_are_unreachable = false; let mut unreachable_blocks = HashSet::default(); - self.simple_reachable_blocks_optimization(|context| { + self.simple_reachable_pre_order_blocks_optimization(|context| { let block_id = context.block_id; if current_block_id != Some(block_id) { @@ -219,6 +219,41 @@ mod test { "#); } + #[test] + fn removes_unreachable_instructions_from_successors_goes_in_pre_order() { + let src = r#" + acir(inline) predicate_pure fn main f0 { + b0(): + v0 = make_array [] : [&mut u1; 0] + constrain u1 0 == u1 1, "Index out of bounds" + v4 = array_get v0, index u32 0 -> &mut u1 + v5 = load v4 -> u1 + jmp b2(v5) + b1(v8: u1): + v9 = add v8, u1 1 + return v9 + b2(v6: u1): + v7 = add v6, u1 1 + jmp b1(v7) + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + v2 = make_array [] : [&mut u1; 0] + constrain u1 0 == u1 1, "Index out of bounds" + jmp b2(u1 0) + b1(v0: u1): + return u1 0 + b2(v1: u1): + jmp b1(u1 0) + } + "#); + } + #[test] fn does_not_remove_unreachable_instructions_from_successor_if_they_have_other_predecessors() { let src = r#" diff --git a/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs b/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs index 63a9e43099b..3091dedc51c 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs @@ -34,6 +34,20 @@ impl Function { .expect("`f` cannot error internally so this should be unreachable"); } + /// Similar to `simple_reachable_blocks_optimization` but traverses the blocks in pre-order. + pub(crate) fn simple_reachable_pre_order_blocks_optimization(&mut self, mut f: F) + where + F: FnMut(&mut SimpleOptimizationContext<'_, '_>), + { + let blocks = self.reachable_pre_order_blocks().into_iter(); + + self.simple_optimization_result(blocks, move |context| { + f(context); + Ok(()) + }) + .expect("`f` cannot error internally so this should be unreachable"); + } + /// Performs a simple optimization according to the given callback, returning early if /// an error occurred. /// @@ -48,8 +62,17 @@ impl Function { /// /// `replace_value` can be used to replace a value with another one. This substitution will be /// performed in all subsequent instructions. - pub(crate) fn simple_reachable_blocks_optimization_result( + pub(crate) fn simple_reachable_blocks_optimization_result(&mut self, f: F) -> RtResult<()> + where + F: FnMut(&mut SimpleOptimizationContext<'_, '_>) -> RtResult<()>, + { + let blocks = self.reachable_blocks().into_iter(); + self.simple_optimization_result(blocks, f) + } + + fn simple_optimization_result( &mut self, + blocks: impl Iterator, mut f: F, ) -> RtResult<()> where @@ -57,7 +80,7 @@ impl Function { { let mut values_to_replace = ValueMapping::default(); - for block_id in self.reachable_blocks() { + for block_id in blocks { let instruction_ids = self.dfg[block_id].take_instructions(); self.dfg[block_id].instructions_mut().reserve(instruction_ids.len()); for instruction_id in &instruction_ids { From aaa9c0e24a8bd515bac7e5c129f6e68c87484935 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 15:25:28 -0300 Subject: [PATCH 08/41] All successors are unreachable unless we saw them before --- .../opt/remove_unreachable_instructions.rs | 122 +++++++++++++----- 1 file changed, 90 insertions(+), 32 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 93aeecf7b1a..0cf63cc90f1 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -3,8 +3,8 @@ //! any subsequent instructions in that block will never be executed. This pass //! then removes those subsequent instructions and replaces the block's terminator //! values with zeroed values of the appropriate type. If the block has successors -//! whose predecessors are that block only, those successors will also be unreachable -//! so the same treatment is applied to them. +//! those successors will also be unreachable if they come afterwards in a pre-order +//! traversal. use std::sync::Arc; use acvm::{AcirField, FieldElement}; @@ -13,8 +13,8 @@ use noirc_errors::call_stack::CallStackId; use crate::ssa::{ ir::{ - basic_block::BasicBlockId, cfg::ControlFlowGraph, function::Function, - instruction::Instruction, types::Type, value::ValueId, + basic_block::BasicBlockId, function::Function, instruction::Instruction, types::Type, + value::ValueId, }, ssa_gen::Ssa, }; @@ -30,10 +30,19 @@ impl Ssa { impl Function { fn remove_unreachable_instructions(&mut self) { - let cfg = ControlFlowGraph::with_function(self); - + // The current block we are currently processing let mut current_block_id = None; + + // Whether the current block instructions were determined to be unreachable let mut current_block_instructions_are_unreachable = false; + + // This is the set of all blocks we've seen so far. We need to keep this because when + // we determine that a block is unreachable, all of its successors are also unreachable + // but only if we didn't see them before. + let mut seen_blocks = HashSet::default(); + + // This is the final set of blocks that we concluded have some unreachable instructions. + // At the end we'll zero out their terminators. let mut unreachable_blocks = HashSet::default(); self.simple_reachable_pre_order_blocks_optimization(|context| { @@ -44,8 +53,14 @@ impl Function { current_block_instructions_are_unreachable = unreachable_blocks.contains(&block_id); if current_block_instructions_are_unreachable { - add_successors(block_id, &cfg, &mut unreachable_blocks); + for successor in context.dfg[block_id].successors() { + if !seen_blocks.contains(&successor) { + unreachable_blocks.insert(successor); + } + } } + + seen_blocks.insert(block_id); } if current_block_instructions_are_unreachable { @@ -77,10 +92,14 @@ impl Function { }; if is_unreachable { - current_block_instructions_are_unreachable = true; unreachable_blocks.insert(block_id); + current_block_instructions_are_unreachable = true; - add_successors(block_id, &cfg, &mut unreachable_blocks); + for successor in context.dfg[block_id].successors() { + if !seen_blocks.contains(&successor) { + unreachable_blocks.insert(successor); + } + } } }); @@ -95,21 +114,6 @@ impl Function { } } -/// Adds all of a block's successors to the `blocks` set, if each of those successors -/// have the given block as their only predecessor. -fn add_successors( - block_id: BasicBlockId, - cfg: &ControlFlowGraph, - blocks: &mut HashSet, -) { - for successor in cfg.successors(block_id) { - let successor_predecessors = cfg.predecessors(successor).collect::>(); - if successor_predecessors.len() == 1 && successor_predecessors[0] == block_id { - blocks.insert(successor); - } - } -} - fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> ValueId { match typ { Type::Numeric(numeric_type) => { @@ -154,10 +158,7 @@ fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> #[cfg(test)] mod test { - use crate::{ - assert_ssa_snapshot, - ssa::{opt::assert_normalized_ssa_equals, ssa_gen::Ssa}, - }; + use crate::{assert_ssa_snapshot, ssa::ssa_gen::Ssa}; #[test] fn removes_unreachable_instructions_in_block() { @@ -255,21 +256,78 @@ mod test { } #[test] - fn does_not_remove_unreachable_instructions_from_successor_if_they_have_other_predecessors() { + fn removes_unreachable_instructions_if_successor_has_other_predecessors() { let src = r#" acir(inline) predicate_pure fn main f0 { b0(): - jmpif u1 0 then: b1, else: b2 + constrain u1 0 == u1 1, "Index out of bounds" + jmp b1() b1(): + v1 = add Field 1, Field 2 + jmpif u1 0 then: b2, else: b3 + b2(): + v2 = add Field 1, Field 2 + jmp b1() + b3(): + v3 = add Field 1, Field 2 + return v3 + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): constrain u1 0 == u1 1, "Index out of bounds" - jmp b2() + jmp b1() + b1(): + jmpif u1 0 then: b2, else: b3 + b2(): + jmp b1() + b3(): + return Field 0 + } + "#); + } + + #[test] + fn does_not_zeroes_terminator_of_previously_seen_blocks() { + let src = r#" + acir(inline) predicate_pure fn main f0 { + b0(): + jmp b1() + b1(): + v2 = add Field 1, Field 2 + jmp b2(v2) b2(): + jmpif u1 0 then: b3, else: b4 + b3(): + constrain u1 0 == u1 1, "Index out of bounds" + jmpif u1 0 then: b4, else: b1 + b4(): v1 = add Field 1, Field 2 return v1 } "#; let ssa = Ssa::from_str(src).unwrap(); let ssa = ssa.remove_unreachable_instructions(); - assert_normalized_ssa_equals(ssa, src); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + jmp b1() + b1(): + v2 = add Field 1, Field 2 + jmp b2(v2) + b2(): + jmpif u1 0 then: b3, else: b4 + b3(): + constrain u1 0 == u1 1, "Index out of bounds" + jmpif u1 0 then: b4, else: b1 + b4(): + return Field 0 + } + "#); } } From d0d9ab279091ed633007f2106f29cc2c635b04a2 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 15:34:32 -0300 Subject: [PATCH 09/41] Update snapshots --- ...rillig_true_inliner_-9223372036854775808.snap | 12 ++---------- ...ute__tests__force_brillig_true_inliner_0.snap | 12 ++---------- ...rillig_true_inliner_-9223372036854775808.snap | 16 ++-------------- ...ute__tests__force_brillig_true_inliner_0.snap | 16 ++-------------- ...brillig_true_inliner_9223372036854775807.snap | 16 ++-------------- ...rillig_true_inliner_-9223372036854775808.snap | 4 ++-- ...ute__tests__force_brillig_true_inliner_0.snap | 4 ++-- ...brillig_true_inliner_9223372036854775807.snap | 4 ++-- 8 files changed, 16 insertions(+), 68 deletions(-) diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index e123684b80d..e17d66c6564 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -66,10 +66,6 @@ expression: artifact "error_kind": "string", "string": "attempt to add with overflow" }, - "12049594436772143978": { - "error_kind": "string", - "string": "array ref-count underflow detected" - }, "14225679739041873922": { "error_kind": "string", "string": "Index out of bounds" @@ -88,14 +84,10 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 427 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 353 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(5), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(10), source: Relative(8) }, Store { destination_pointer: Relative(10), source: Direct(32837) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(9) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Direct(32838) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Relative(7) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(10) }, Call { location: 433 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(8), source: Relative(12) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, JumpIf { condition: Relative(8), location: 180 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(7), location: 224 }, Jump { location: 184 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 189 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(10), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(11), source: Direct(32773) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, Load { destination: Relative(10), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Div, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(14), op: Div, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: Sub, bit_size: U32, lhs: Relative(10), rhs: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 207 }, Call { location: 513 }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(5) }, Store { destination_pointer: Relative(13), source: Relative(10) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Cast { destination: Relative(10), source: Relative(1), bit_size: Field }, Const { destination: Relative(1), bit_size: Field, value: 10 }, BinaryFieldOp { destination: Relative(11), op: Div, lhs: Relative(1), rhs: Relative(10) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(10), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 223 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Jump { location: 233 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(2), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Jump { location: 233 }, Load { destination: Relative(1), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, JumpIf { condition: Relative(1), location: 240 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(8) }, JumpIf { condition: Relative(7), location: 248 }, Jump { location: 245 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 260 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 260 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 267 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 274 }, Call { location: 516 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 433 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 290 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(7), location: 298 }, Jump { location: 295 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 313 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(3) }, Store { destination_pointer: Relative(6), source: Relative(4) }, JumpIf { condition: Relative(7), location: 311 }, Jump { location: 308 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 313 }, Store { destination_pointer: Relative(1), source: Relative(5) }, Jump { location: 313 }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32835) }, JumpIf { condition: Relative(2), location: 319 }, Jump { location: 321 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 321 }, Load { destination: Relative(3), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 326 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(2), source: Direct(32835) }, Jump { location: 331 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(3), location: 340 }, Jump { location: 334 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 339 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 347 }, Jump { location: 350 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(5) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 350 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 331 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 356 }, Jump { location: 362 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 358 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 365 }, Jump { location: 361 }, Jump { location: 362 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 369 }, Call { location: 513 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 374 }, Call { location: 519 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 377 }, Call { location: 522 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 384 }, Call { location: 522 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 491 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 394 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 414 }, Jump { location: 397 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 401 }, Jump { location: 411 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 411 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 358 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 423 }, Call { location: 513 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 394 }, 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: 432 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 427 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 439 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 444 }, Jump { location: 442 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 446 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 452 }, Jump { location: 449 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 439 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 459 }, Call { location: 522 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 465 }, Jump { location: 488 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 488 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 446 }, 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: 495 }, Jump { location: 497 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 512 }, 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: 509 }, 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: 502 }, 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: 512 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 297 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(3), location: 223 }, Jump { location: 138 }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 145 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 153 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Relative(7), source: Relative(5) }, Store { destination_pointer: Relative(7), source: Direct(32837) }, 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(9) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32838) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 303 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, JumpIf { condition: Relative(3), location: 180 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 190 }, Jump { location: 183 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 189 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Jump { location: 199 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(3), source: Direct(32773) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Store { destination_pointer: Relative(4), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 199 }, JumpIf { condition: Relative(2), location: 202 }, Jump { location: 201 }, Jump { location: 203 }, Jump { location: 203 }, JumpIf { condition: Relative(2), location: 206 }, Jump { location: 205 }, Jump { location: 210 }, JumpIf { condition: Relative(2), location: 209 }, Jump { location: 208 }, Jump { location: 210 }, Jump { location: 210 }, JumpIf { condition: Relative(2), location: 212 }, Jump { location: 213 }, Jump { location: 213 }, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 215 }, JumpIf { condition: Relative(2), location: 218 }, Jump { location: 217 }, Return, JumpIf { condition: Relative(2), location: 220 }, Jump { location: 221 }, Jump { location: 221 }, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 215 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 226 }, Jump { location: 232 }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 228 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 235 }, Jump { location: 231 }, Jump { location: 232 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(3) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(12), location: 239 }, Call { location: 383 }, Load { destination: Relative(12), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, JumpIf { condition: Relative(14), location: 244 }, Call { location: 386 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, JumpIf { condition: Relative(14), location: 247 }, Call { location: 389 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Load { destination: Relative(12), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 254 }, Call { location: 389 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 361 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Store { destination_pointer: Relative(16), source: Relative(14) }, Store { destination_pointer: Relative(7), source: Relative(13) }, Mov { destination: Relative(4), source: Direct(32835) }, Jump { location: 264 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(11), location: 284 }, Jump { location: 267 }, Load { destination: Relative(4), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, JumpIf { condition: Relative(11), location: 271 }, Jump { location: 281 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Load { destination: Relative(11), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 281 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 228 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 293 }, Call { location: 383 }, Store { destination_pointer: Relative(2), source: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Mov { destination: Relative(4), source: Relative(11) }, Jump { location: 264 }, 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: 302 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 297 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 309 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 314 }, Jump { location: 312 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 322 }, Jump { location: 319 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 309 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 329 }, Call { location: 389 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 335 }, Jump { location: 358 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 358 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 316 }, 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: 365 }, Jump { location: 367 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 382 }, 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: 379 }, 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: 372 }, 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: 382 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZnNbhtJDITfRWcf+o/9k1cJgkBxlECAIBuKvcAi8Lsva5rVEx+8CKiL67NkltgcsqdH/n34fvr2+vPr+frj6dfh0+ffh2+38+Vy/vn18vR4fDk/XfXV34eAHzGqxAfVaJpMs2kxFdNq2ky76ZiazC+ZXzK/ZH7J/JL5JfNL5pfML5lf1r9LUH09Q/X1olqCqX6OQJNpNi2mYqqfU6HNtJuOqRJMo2kyVb8GLaZiWk2baTcdU2swjabJ1Pyq+VXzq+ZX1a9Du+mY2oJpNE2m2VT9BlRMUdcAaIROGAYd1wpF7rgoqG4XQiU0QicgHKUfCEdtRyQkQiYUghDgjMqORoAz1j7grItJIRAiIRHgPACFIIRKUOcUAJ0wDNDuEyIhETJBnVMEoPcSoBLgnAGdMAzQ+BMiIRFgWAAwFEAlNEInDIMcCJGQzTDDsAKEAMMGaIROGAYYmYQaYmYmJAJ8UDqMyQTMG4qAAdkAEzIhEhIhEwpBCGqYUToMyoRugBHZPgszkrEuDMkEGKJiGJMJQqiERuiEYYBhmRAJiUDnRudGZ4xMRp0xMhM6YRhgZCZEQiJkApxxUTBNE+CMS4BpmtAJwwDTlHEtME0TEgE+KBRmZ4KGF/QqRgaQMTITIiERMqEQhACfCBgGmIuSAIjKAEQVgBA0jSIAROkCM3p+Aj60ATKhEISA8A5oBKSh68podUFi6HBBPuhwQT7o8AmN0A3Q2FvUdjNAztvdYINMgCGSxw1gc0aHb4DGnoA/xrrQooLlbA0JRRbIHd03oRE6YRig+wTLQvdNSIRMKAQhVAKcUQx034RhgO6bEAmJkAnqXFEMdN+ESmiEThgG6L4JkQAfVAX7dEWZ0XRVq1HQYhMSIW91KuiwTcW0mjbTbjqmots2tQ8r6LEJSLoAGqETxkyoYMudEAmJkAnFAB1VBSCESoChXu6CtqkNgLc6YNgr23kAr6BJ6gAUghAqoRE6AccCLWvZzgUbRAJOBljydhTYAGcB5Iwmm9AJ8EHF0GQTIgE+qA+abEIhCKESGqETuFI02YRIYFnQZBMKQQiVgCW3t7eHA0+bX19upxMOm38cP/VQ+ny8na4vh0/X18vl4fDP8fK6/dGv5+N105fjTd/VCp2u31XV8Mf5cgK9PezR4eNQ7ToL1rZa4fL38RjHGV+DI75lJt9yccT3wPge+n3xMXviE+vXs6d+A3fVLX744nGYs/jmiReuf0i5M3544tuKb9URHwPuv5tBDPJhB8T0sUXCprE56FnGlUKTlYJzEbXvDsnlMPYyjHanQwzR46DXYjnEcG8OTode9zq4HGIaK4c8XA6yctBH2bsdfD259oUYkq+SMS2H6OpqfRxeqxjpbgdXV6fI/VnRVcm8dnhFl0OSPYf24Sry/yaB854l8ccWE8ffJzF2h+BqiCyrITQdl0Np9zq0PYfmGs48dodR73Qovo2y5NXWxbfF1Li22uo6t+l3feumpQdmj4PsG4S4zk76feGqgxRfHfLKoWbXcFbZKyl3O/i2+9pWHaqvq+tYDi14znH63eiazVZcdWiy5+CrQ+trj2rddcPoaV2Lnl3T3fe56M013W2sm3f37bTvHDzTLeskJtHTDVJ4IaR4roNULkBcNZTGZpReXfGy4psr/7V+13G8rlNHdR06amH9fHtSHfz8FjzrrxLv+vx7H6lkXT7fDK+tbHi6r431lYLniXZ/lPM9ye0Pk+O+j/edj+p+uPHdDdetzHeq2G+F78v3RX87Pp5v7/5B+wan2/n47XKyX3+8Xh//ePfl32e+w3/wPt+eHk/fX28nOO3/5dUfn4sekvVY80W/yNXfRniIIegvcXtPnwNKxnv4Qvaz6AOWpPjlDZn9Bw==", + "debug_symbols": "pZfNbtswEITfxWcfyOXfsq8SBIGTKIUBwwkcu0AR+N27I+0oySFAQV88nyTPiOSuaOtj8zw9Xn4/7I8vr++bX3cfm8fT/nDY/344vD7tzvvXo5392AR8xGgSt6bRVVyTa3YtrtW1uaprX1Q8TzxPPE88TzxPPE88TzxPPE88L9n3BGrnE9TOZ9McXO0+BSquyTW7Fle7T4U2V3Xti5bgGl3F1fIaNLsW1+raXNW1L1qDa3QVV8+rnlc9r3petTyFqmtftAXX6CquydXyOrS4Yl0DoBGU0B0UtcIiK4qD1dVMKIRKaAR16LCjBh21xiJ3ISRCJhRCJbQFZG6NCkCyLYIkmYstKH5UQCU0ghK6AzoidkAkCCERMqEQKsGSJQCU0B3QGwtEghASwZIlAgqhEhpBCd0BXbJAJCBHAHBhEdAJYsssKP0CQkjLOqH4sxbX6tpc1bUvqtGVN0O5F8CgURSUewEldB8Q6r5AJAghEfICKQAqoBAqAYFW7oQ9RxSASx3Q/Qy2j/kMmiQFQCYUQiU0ghIwYVvWlAIhEtBjAigE5GDMaLIFlIAcW/GEJlsgEpBTAImQCYVQCY2gBM50brIZIoHLMjfZDJlQCJWAMun1ut1wk384n6YJe/yXXd9+C952p+l43vw6Xg6H7ebP7nCZv/T+tjvOet6d7Kot3nR8NrXAl/1hAl23n+7wszWH5uYcy2ov/+8vSn8NA/6WOPiW8oBfA/0a9DZ/TCN+4fppGlm/jrac/X3Mj+3Q/W3EXzj/XvKN/j7ib6u/1QF/DDl5QAzlxw6I8nOE7dCeYFvv0BDWGsQgYSxB1oQ4sgwlsI1KHCljyZH+LCP+WulvccTf+BgVHZp/K6u/DY1/nX8bmX+NHH+NIz1UM9evliF/5/1bGJl/LfGm+9/6DJW1fEObgHL29u925Eeor78hI1uYfj79Qw9/Wf39ttuP2GNi59lb2oi/rsOvQ/df/0DYW9c3/70d7Z72p28vwlcknfa7x8Pkhy+X49OXq+e/b7zCF+m30+vT9Hw5TUj6fJu2j7tkz31Subf/ZHbUwzaGYAd4z74Te6ZSwDW8bt8lrfZVvb9iZP8A", "file_map": { - "19": { - "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", "path": "" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap index e123684b80d..e17d66c6564 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap @@ -66,10 +66,6 @@ expression: artifact "error_kind": "string", "string": "attempt to add with overflow" }, - "12049594436772143978": { - "error_kind": "string", - "string": "array ref-count underflow detected" - }, "14225679739041873922": { "error_kind": "string", "string": "Index out of bounds" @@ -88,14 +84,10 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 427 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 353 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(5), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(10), source: Relative(8) }, Store { destination_pointer: Relative(10), source: Direct(32837) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(9) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Direct(32838) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Relative(7) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(10) }, Call { location: 433 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(8), source: Relative(12) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, JumpIf { condition: Relative(8), location: 180 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(7), location: 224 }, Jump { location: 184 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(10), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 189 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(10), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(11), source: Direct(32773) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Store { destination_pointer: Relative(12), source: Direct(32837) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, Load { destination: Relative(10), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(12), op: Div, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(14), op: Div, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Mul, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, BinaryIntOp { destination: Relative(13), op: Sub, bit_size: U32, lhs: Relative(10), rhs: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 207 }, Call { location: 513 }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(5) }, Store { destination_pointer: Relative(13), source: Relative(10) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Cast { destination: Relative(10), source: Relative(1), bit_size: Field }, Const { destination: Relative(1), bit_size: Field, value: 10 }, BinaryFieldOp { destination: Relative(11), op: Div, lhs: Relative(1), rhs: Relative(10) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(10), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 223 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Jump { location: 233 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(2), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Jump { location: 233 }, Load { destination: Relative(1), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(2), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, JumpIf { condition: Relative(1), location: 240 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(8) }, JumpIf { condition: Relative(7), location: 248 }, Jump { location: 245 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 260 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 260 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 267 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 274 }, Call { location: 516 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 433 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 290 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(7), location: 298 }, Jump { location: 295 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 313 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(3) }, Store { destination_pointer: Relative(6), source: Relative(4) }, JumpIf { condition: Relative(7), location: 311 }, Jump { location: 308 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 313 }, Store { destination_pointer: Relative(1), source: Relative(5) }, Jump { location: 313 }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32835) }, JumpIf { condition: Relative(2), location: 319 }, Jump { location: 321 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 321 }, Load { destination: Relative(3), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 326 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(2), source: Direct(32835) }, Jump { location: 331 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(3), location: 340 }, Jump { location: 334 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 339 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 347 }, Jump { location: 350 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(5) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 350 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 331 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 356 }, Jump { location: 362 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 358 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 365 }, Jump { location: 361 }, Jump { location: 362 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 369 }, Call { location: 513 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 374 }, Call { location: 519 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 377 }, Call { location: 522 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 384 }, Call { location: 522 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 491 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 394 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 414 }, Jump { location: 397 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 401 }, Jump { location: 411 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 411 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 358 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 423 }, Call { location: 513 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 394 }, 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: 432 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 427 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 439 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 444 }, Jump { location: 442 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 446 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 452 }, Jump { location: 449 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 439 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 459 }, Call { location: 522 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 465 }, Jump { location: 488 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 491 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 488 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 446 }, 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: 495 }, Jump { location: 497 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 512 }, 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: 509 }, 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: 502 }, 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: 512 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 297 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(3), location: 223 }, Jump { location: 138 }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 145 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 153 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Relative(7), source: Relative(5) }, Store { destination_pointer: Relative(7), source: Direct(32837) }, 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(9) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32838) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 303 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, JumpIf { condition: Relative(3), location: 180 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 190 }, Jump { location: 183 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 189 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Jump { location: 199 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(3), source: Direct(32773) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Store { destination_pointer: Relative(4), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 199 }, JumpIf { condition: Relative(2), location: 202 }, Jump { location: 201 }, Jump { location: 203 }, Jump { location: 203 }, JumpIf { condition: Relative(2), location: 206 }, Jump { location: 205 }, Jump { location: 210 }, JumpIf { condition: Relative(2), location: 209 }, Jump { location: 208 }, Jump { location: 210 }, Jump { location: 210 }, JumpIf { condition: Relative(2), location: 212 }, Jump { location: 213 }, Jump { location: 213 }, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 215 }, JumpIf { condition: Relative(2), location: 218 }, Jump { location: 217 }, Return, JumpIf { condition: Relative(2), location: 220 }, Jump { location: 221 }, Jump { location: 221 }, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 215 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 226 }, Jump { location: 232 }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 228 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 235 }, Jump { location: 231 }, Jump { location: 232 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(3) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(12), location: 239 }, Call { location: 383 }, Load { destination: Relative(12), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, JumpIf { condition: Relative(14), location: 244 }, Call { location: 386 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, JumpIf { condition: Relative(14), location: 247 }, Call { location: 389 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Load { destination: Relative(12), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 254 }, Call { location: 389 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 361 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Store { destination_pointer: Relative(16), source: Relative(14) }, Store { destination_pointer: Relative(7), source: Relative(13) }, Mov { destination: Relative(4), source: Direct(32835) }, Jump { location: 264 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(11), location: 284 }, Jump { location: 267 }, Load { destination: Relative(4), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, JumpIf { condition: Relative(11), location: 271 }, Jump { location: 281 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Load { destination: Relative(11), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 281 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 228 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 293 }, Call { location: 383 }, Store { destination_pointer: Relative(2), source: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Mov { destination: Relative(4), source: Relative(11) }, Jump { location: 264 }, 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: 302 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 297 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 309 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 314 }, Jump { location: 312 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 322 }, Jump { location: 319 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 309 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 329 }, Call { location: 389 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 335 }, Jump { location: 358 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 358 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 316 }, 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: 365 }, Jump { location: 367 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 382 }, 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: 379 }, 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: 372 }, 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: 382 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZnNbhtJDITfRWcf+o/9k1cJgkBxlECAIBuKvcAi8Lsva5rVEx+8CKiL67NkltgcsqdH/n34fvr2+vPr+frj6dfh0+ffh2+38+Vy/vn18vR4fDk/XfXV34eAHzGqxAfVaJpMs2kxFdNq2ky76ZiazC+ZXzK/ZH7J/JL5JfNL5pfML5lf1r9LUH09Q/X1olqCqX6OQJNpNi2mYqqfU6HNtJuOqRJMo2kyVb8GLaZiWk2baTcdU2swjabJ1Pyq+VXzq+ZX1a9Du+mY2oJpNE2m2VT9BlRMUdcAaIROGAYd1wpF7rgoqG4XQiU0QicgHKUfCEdtRyQkQiYUghDgjMqORoAz1j7grItJIRAiIRHgPACFIIRKUOcUAJ0wDNDuEyIhETJBnVMEoPcSoBLgnAGdMAzQ+BMiIRFgWAAwFEAlNEInDIMcCJGQzTDDsAKEAMMGaIROGAYYmYQaYmYmJAJ8UDqMyQTMG4qAAdkAEzIhEhIhEwpBCGqYUToMyoRugBHZPgszkrEuDMkEGKJiGJMJQqiERuiEYYBhmRAJiUDnRudGZ4xMRp0xMhM6YRhgZCZEQiJkApxxUTBNE+CMS4BpmtAJwwDTlHEtME0TEgE+KBRmZ4KGF/QqRgaQMTITIiERMqEQhACfCBgGmIuSAIjKAEQVgBA0jSIAROkCM3p+Aj60ATKhEISA8A5oBKSh68podUFi6HBBPuhwQT7o8AmN0A3Q2FvUdjNAztvdYINMgCGSxw1gc0aHb4DGnoA/xrrQooLlbA0JRRbIHd03oRE6YRig+wTLQvdNSIRMKAQhVAKcUQx034RhgO6bEAmJkAnqXFEMdN+ESmiEThgG6L4JkQAfVAX7dEWZ0XRVq1HQYhMSIW91KuiwTcW0mjbTbjqmots2tQ8r6LEJSLoAGqETxkyoYMudEAmJkAnFAB1VBSCESoChXu6CtqkNgLc6YNgr23kAr6BJ6gAUghAqoRE6AccCLWvZzgUbRAJOBljydhTYAGcB5Iwmm9AJ8EHF0GQTIgE+qA+abEIhCKESGqETuFI02YRIYFnQZBMKQQiVgCW3t7eHA0+bX19upxMOm38cP/VQ+ny8na4vh0/X18vl4fDP8fK6/dGv5+N105fjTd/VCp2u31XV8Mf5cgK9PezR4eNQ7ToL1rZa4fL38RjHGV+DI75lJt9yccT3wPge+n3xMXviE+vXs6d+A3fVLX744nGYs/jmiReuf0i5M3544tuKb9URHwPuv5tBDPJhB8T0sUXCprE56FnGlUKTlYJzEbXvDsnlMPYyjHanQwzR46DXYjnEcG8OTode9zq4HGIaK4c8XA6yctBH2bsdfD259oUYkq+SMS2H6OpqfRxeqxjpbgdXV6fI/VnRVcm8dnhFl0OSPYf24Sry/yaB854l8ccWE8ffJzF2h+BqiCyrITQdl0Np9zq0PYfmGs48dodR73Qovo2y5NXWxbfF1Li22uo6t+l3feumpQdmj4PsG4S4zk76feGqgxRfHfLKoWbXcFbZKyl3O/i2+9pWHaqvq+tYDi14znH63eiazVZcdWiy5+CrQ+trj2rddcPoaV2Lnl3T3fe56M013W2sm3f37bTvHDzTLeskJtHTDVJ4IaR4roNULkBcNZTGZpReXfGy4psr/7V+13G8rlNHdR06amH9fHtSHfz8FjzrrxLv+vx7H6lkXT7fDK+tbHi6r431lYLniXZ/lPM9ye0Pk+O+j/edj+p+uPHdDdetzHeq2G+F78v3RX87Pp5v7/5B+wan2/n47XKyX3+8Xh//ePfl32e+w3/wPt+eHk/fX28nOO3/5dUfn4sekvVY80W/yNXfRniIIegvcXtPnwNKxnv4Qvaz6AOWpPjlDZn9Bw==", + "debug_symbols": "pZfNbtswEITfxWcfyOXfsq8SBIGTKIUBwwkcu0AR+N27I+0oySFAQV88nyTPiOSuaOtj8zw9Xn4/7I8vr++bX3cfm8fT/nDY/344vD7tzvvXo5392AR8xGgSt6bRVVyTa3YtrtW1uaprX1Q8TzxPPE88TzxPPE88TzxPPE88L9n3BGrnE9TOZ9McXO0+BSquyTW7Fle7T4U2V3Xti5bgGl3F1fIaNLsW1+raXNW1L1qDa3QVV8+rnlc9r3petTyFqmtftAXX6CquydXyOrS4Yl0DoBGU0B0UtcIiK4qD1dVMKIRKaAR16LCjBh21xiJ3ISRCJhRCJbQFZG6NCkCyLYIkmYstKH5UQCU0ghK6AzoidkAkCCERMqEQKsGSJQCU0B3QGwtEghASwZIlAgqhEhpBCd0BXbJAJCBHAHBhEdAJYsssKP0CQkjLOqH4sxbX6tpc1bUvqtGVN0O5F8CgURSUewEldB8Q6r5AJAghEfICKQAqoBAqAYFW7oQ9RxSASx3Q/Qy2j/kMmiQFQCYUQiU0ghIwYVvWlAIhEtBjAigE5GDMaLIFlIAcW/GEJlsgEpBTAImQCYVQCY2gBM50brIZIoHLMjfZDJlQCJWAMun1ut1wk384n6YJe/yXXd9+C952p+l43vw6Xg6H7ebP7nCZv/T+tjvOet6d7Kot3nR8NrXAl/1hAl23n+7wszWH5uYcy2ov/+8vSn8NA/6WOPiW8oBfA/0a9DZ/TCN+4fppGlm/jrac/X3Mj+3Q/W3EXzj/XvKN/j7ib6u/1QF/DDl5QAzlxw6I8nOE7dCeYFvv0BDWGsQgYSxB1oQ4sgwlsI1KHCljyZH+LCP+WulvccTf+BgVHZp/K6u/DY1/nX8bmX+NHH+NIz1UM9evliF/5/1bGJl/LfGm+9/6DJW1fEObgHL29u925Eeor78hI1uYfj79Qw9/Wf39ttuP2GNi59lb2oi/rsOvQ/df/0DYW9c3/70d7Z72p28vwlcknfa7x8Pkhy+X49OXq+e/b7zCF+m30+vT9Hw5TUj6fJu2j7tkz31Subf/ZHbUwzaGYAd4z74Te6ZSwDW8bt8lrfZVvb9iZP8A", "file_map": { - "19": { - "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", "path": "" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 301e669f51a..ce476a4872d 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -58,10 +58,6 @@ expression: artifact ], "return_type": null, "error_types": { - "12049594436772143978": { - "error_kind": "string", - "string": "array ref-count underflow detected" - }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" @@ -76,18 +72,10 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32837) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32842 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32847 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 104 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 162 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(6), location: 113 }, Jump { location: 118 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(6), location: 117 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 118 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(7), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Relative(6) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 168 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(7), location: 130 }, Jump { location: 146 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, 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: Direct(32836) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, 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) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 146 }, Load { destination: Relative(6), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 154 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(3) }, Mov { destination: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 178 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 167 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 162 }, Const { destination: Relative(2), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 173 }, Jump { location: 177 }, Const { destination: Relative(1), bit_size: Field, value: 1 }, Const { destination: Relative(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(3), op: Div, lhs: Relative(1), rhs: Relative(2) }, Jump { location: 177 }, Return, Call { location: 162 }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 185 }, Call { location: 207 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(7), size: 32 } }), Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(3) }, Mov { destination: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 210 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, JumpIf { condition: Relative(1), location: 206 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 162 }, 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(32835) }, 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: 220 }, Call { location: 207 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 226 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, JumpIf { condition: Relative(5), location: 231 }, Jump { location: 229 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(5), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 226 }]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 121 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(5), location: 111 }, Jump { location: 117 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 116 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 117 }, JumpIf { condition: Relative(1), location: 119 }, Jump { location: 120 }, Jump { location: 120 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 126 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZbNbuJAEITfxWcO0z3/vEoURQZMZMkyyIGVVoh33+7QBezBEXIu1Gc8VR7a3caXZtdtzp8f/bg/fDXrt0uzmfph6D8/hsO2PfWHUb69NE4/yJVmTSvRelPyzZpVg2k0Taay3qvK+iDKzpRM2dSbBlPJiarppl58WZVM2dSbBtNomkyzaTGtNw2WFywvWF6wvCB5STWZSk5RLaaSU0WjMyVTNvWmkkNOIQISIAMKoBokB9BvtM7ZASSYtKI5ACIA9gJ7IQADPAAbK9hYwcaKbkyLXgqgGlQHIAADPCAANFmLVxMgAwqg3oCdAxCAAR4QAJbMhMWExYTF2pGUFSIgATKgAKqB9ucNCAAX6xq59+xxSpuQqoIHBIDOgVNIgAyQizIrIFCb8QaaXK7XVYPR+zhNXaeT9zSLMqHHdurGU7Mez8Owav60w/l70dexHb/11E5yVq7WjTtRCdz3Q6d0XT3cbt5KxGaW0b3b4+t+n+EPvMQfK/xp0fVjhD+7Jf6C4slcLPBLG5ufXZnzp3l/YvgTL6kfM+ov7fpL/6LfHzz8qSzw+xDM7+OS/fuE/vUpz/m1x2cDHArgyS/YQAho4DDfwBR+mqCEFpBhetwDGccXtxADahDjknsgT2ncBHlOh0fC60Pg6n0KfF0SQI8ATksCvHvsoPx2B3M/QYd1topM90che/ec8C4H7baf/nvRumrU1LebobPD/XncPp09/T3iDF7UjtNh2+3OU6dJj7c1+Vd6q25Fzr3rK5sckYwFpayH8lfzxtLk7Or7VffyDw==", + "debug_symbols": "jZDdCsMgDIXfJddeGPfH+iqjFNumQxBbnA5G8d0XN7u1F4Pd+BnjOQlnhp7aeG2MG8YbVJcZWm+sNdfGjp0OZnT8OoPMB8ojVCiYpzcRoVKZqnBXuC88MFMSsHg1wRNlq5U5j5y0JxegctFaAXdt4+vTbdLuxaA9d6UAcj2TDQdjKd+S+KrlbylvWMSI54/88L9+d1r0e7XR11zpzvhNXCk7eaNbS6UcoutW3fCYls4S9+THjvroKTt9M+dEL2cpUMo6B88VKhSojnXKw58=", "file_map": { - "5": { - "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", - "path": "std/cmp.nr" - }, - "19": { - "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, "50": { "source": "fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //regression for short-circuit2\n if 35 == a {\n assert(false);\n }\n bar(a as Field);\n\n if a == 3 {\n c = test4();\n }\n assert(c[1] != 2);\n call_intrinsic(x, result);\n}\n\nfn foo() {\n let mut x = 1;\n x /= 0;\n}\n\nfn bar(x: Field) {\n if x == 15 {\n foo();\n }\n}\n\nfn call_intrinsic(x: [u8; 5], result: [u8; 32]) {\n let mut digest = std::hash::blake3(x);\n digest[0] = 5 as u8;\n digest = std::hash::blake3(x);\n assert(digest == result);\n}\n\nfn test4() -> [u32; 4] {\n let b: [u32; 4] = [1, 2, 3, 4];\n b\n}\n", "path": "" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap index c1026a7172b..590ae6367f3 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap @@ -58,10 +58,6 @@ expression: artifact ], "return_type": null, "error_types": { - "12049594436772143978": { - "error_kind": "string", - "string": "array ref-count underflow detected" - }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" @@ -76,18 +72,10 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 208 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 112 }, Jump { location: 117 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 116 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Jump { location: 117 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 122 }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 132 }, Jump { location: 148 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 148 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 156 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 162 }, Call { location: 214 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 181 }, Call { location: 214 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 187 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 195 }, Jump { location: 190 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 194 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 187 }, 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: 213 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 131 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(5), location: 111 }, Jump { location: 117 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 116 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 117 }, JumpIf { condition: Relative(1), location: 119 }, Jump { location: 120 }, Jump { location: 120 }, JumpIf { condition: Relative(1), location: 122 }, Jump { location: 123 }, Jump { location: 123 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 126 }, JumpIf { condition: Relative(1), location: 129 }, Jump { location: 128 }, Return, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 126 }, 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: 136 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tZbNbuowEIXfJess7Bn/8ipVhQKEKlIUUApXukK8+50BH8JdBKFU3XQ+Nz7HHntsfKl27eb8te6G/eG7Wn1cqs3Y9X33te4P2+bUHQb576Uy+seaUK1sLTHeo6VqRRq5RFeiL1H6scZUrbzGfI8kuqiRS3Qlin/SGO+RpZ81CgxwAA8IgAhIgFzAGYAFwNnB2cHZwdmJc9aYSlQ7TdsbgNppop4ADHAAD9CJOoUISIBcIBiABRCAAeocFDwgACIgAXKBaAAWoM66ypEBDqDOmnIMgAhIgFwgGYAFEACqLH1I1zRrH93qTAAGYNAsg5Iub46ABJBBSRaTjAFYgNaiU+D7WGQcQMvRXK91hZpen8a21ZJ+KnIp/WMztsOpWg3nvq+rP01/vnX6PjbDLZ6aUb6KZTvsJIrhvutbpWs9qc281Gol3MRyFh5y/76eI/SOluh9hj4sGt976KOZ07t5PTtX9OztEn3A+nGIc/rwQm+wfmx5Sf4Jm29TWKCXci16MmlOn+f1gaAPtGT/iZA/sf2hflH+jqEPs/lb/kUDb3ACPM2eAOtfHcGAPZDTOC2CnOe35+BQxd7PJxF/0UBuVBxEuVPdZPG2g9zA+VHKnBc52MmBwiIHNtMc0o/nMJcFvdhLS/ZxJRObZ4dPaTTbbvzvJXVVq7FrNn1bmvvzsH36evp7xBe8xI7jYdvuzmOrTtNzTH7nPrKprTGf+iaTllwqNVnWptWmvBfIhs+rzuUf", + "debug_symbols": "jZDdDoMgDIXfpddcUN1P5qssxqDWhYSgYbBkMbz7yoZTL5bsho9SzmlzZuipDbdG22G8Q3WdoXXaGH1rzNgpr0fLrzPIdKA8QYWCef4QEaoiscgsMw+ZR2aMAhavxjuiZLUx55GTcmQ9VDYYI+ChTHh/uk/KvumV464UQLZnsuGgDaVbFKta/pbyhlmMePnKj//ry/OiPxQ7fc2V6rTbxRWTk9OqNZTLIdhu0/XPaekscU9u7KgPjpLTmjkner1IgVLWKXiusESB5amOafgL", "file_map": { - "5": { - "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", - "path": "std/cmp.nr" - }, - "19": { - "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, "50": { "source": "fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //regression for short-circuit2\n if 35 == a {\n assert(false);\n }\n bar(a as Field);\n\n if a == 3 {\n c = test4();\n }\n assert(c[1] != 2);\n call_intrinsic(x, result);\n}\n\nfn foo() {\n let mut x = 1;\n x /= 0;\n}\n\nfn bar(x: Field) {\n if x == 15 {\n foo();\n }\n}\n\nfn call_intrinsic(x: [u8; 5], result: [u8; 32]) {\n let mut digest = std::hash::blake3(x);\n digest[0] = 5 as u8;\n digest = std::hash::blake3(x);\n assert(digest == result);\n}\n\nfn test4() -> [u32; 4] {\n let b: [u32; 4] = [1, 2, 3, 4];\n b\n}\n", "path": "" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index c1026a7172b..590ae6367f3 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -58,10 +58,6 @@ expression: artifact ], "return_type": null, "error_types": { - "12049594436772143978": { - "error_kind": "string", - "string": "array ref-count underflow detected" - }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" @@ -76,18 +72,10 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 208 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 112 }, Jump { location: 117 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 116 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Jump { location: 117 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 122 }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 132 }, Jump { location: 148 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 148 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 156 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 162 }, Call { location: 214 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 181 }, Call { location: 214 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 187 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 195 }, Jump { location: 190 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 194 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 187 }, 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: 213 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 131 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(5), location: 111 }, Jump { location: 117 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 116 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 117 }, JumpIf { condition: Relative(1), location: 119 }, Jump { location: 120 }, Jump { location: 120 }, JumpIf { condition: Relative(1), location: 122 }, Jump { location: 123 }, Jump { location: 123 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 126 }, JumpIf { condition: Relative(1), location: 129 }, Jump { location: 128 }, Return, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 126 }, 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: 136 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tZbNbuowEIXfJess7Bn/8ipVhQKEKlIUUApXukK8+50BH8JdBKFU3XQ+Nz7HHntsfKl27eb8te6G/eG7Wn1cqs3Y9X33te4P2+bUHQb576Uy+seaUK1sLTHeo6VqRRq5RFeiL1H6scZUrbzGfI8kuqiRS3Qlin/SGO+RpZ81CgxwAA8IgAhIgFzAGYAFwNnB2cHZwdmJc9aYSlQ7TdsbgNppop4ADHAAD9CJOoUISIBcIBiABRCAAeocFDwgACIgAXKBaAAWoM66ypEBDqDOmnIMgAhIgFwgGYAFEACqLH1I1zRrH93qTAAGYNAsg5Iub46ABJBBSRaTjAFYgNaiU+D7WGQcQMvRXK91hZpen8a21ZJ+KnIp/WMztsOpWg3nvq+rP01/vnX6PjbDLZ6aUb6KZTvsJIrhvutbpWs9qc281Gol3MRyFh5y/76eI/SOluh9hj4sGt976KOZ07t5PTtX9OztEn3A+nGIc/rwQm+wfmx5Sf4Jm29TWKCXci16MmlOn+f1gaAPtGT/iZA/sf2hflH+jqEPs/lb/kUDb3ACPM2eAOtfHcGAPZDTOC2CnOe35+BQxd7PJxF/0UBuVBxEuVPdZPG2g9zA+VHKnBc52MmBwiIHNtMc0o/nMJcFvdhLS/ZxJRObZ4dPaTTbbvzvJXVVq7FrNn1bmvvzsH36evp7xBe8xI7jYdvuzmOrTtNzTH7nPrKprTGf+iaTllwqNVnWptWmvBfIhs+rzuUf", + "debug_symbols": "jZDdDoMgDIXfpddcUN1P5qssxqDWhYSgYbBkMbz7yoZTL5bsho9SzmlzZuipDbdG22G8Q3WdoXXaGH1rzNgpr0fLrzPIdKA8QYWCef4QEaoiscgsMw+ZR2aMAhavxjuiZLUx55GTcmQ9VDYYI+ChTHh/uk/KvumV464UQLZnsuGgDaVbFKta/pbyhlmMePnKj//ry/OiPxQ7fc2V6rTbxRWTk9OqNZTLIdhu0/XPaekscU9u7KgPjpLTmjkner1IgVLWKXiusESB5amOafgL", "file_map": { - "5": { - "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", - "path": "std/cmp.nr" - }, - "19": { - "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, "50": { "source": "fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //regression for short-circuit2\n if 35 == a {\n assert(false);\n }\n bar(a as Field);\n\n if a == 3 {\n c = test4();\n }\n assert(c[1] != 2);\n call_intrinsic(x, result);\n}\n\nfn foo() {\n let mut x = 1;\n x /= 0;\n}\n\nfn bar(x: Field) {\n if x == 15 {\n foo();\n }\n}\n\nfn call_intrinsic(x: [u8; 5], result: [u8; 32]) {\n let mut digest = std::hash::blake3(x);\n digest[0] = 5 as u8;\n digest = std::hash::blake3(x);\n assert(digest == result);\n}\n\nfn test4() -> [u32; 4] {\n let b: [u32; 4] = [1, 2, 3, 4];\n b\n}\n", "path": "" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index b1a9be1926a..ed244e34903 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32859 }, 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(32858), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32858) }, Call { location: 13 }, Call { location: 37 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32859 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Field, 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: Field, value: 1 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32841), bit_size: Field, value: 2 }, Const { destination: Direct(32842), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32843), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32844), bit_size: Field, value: 4 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32846), bit_size: Field, value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 10 }, Const { destination: Direct(32852), bit_size: Field, value: 10 }, Const { destination: Direct(32853), bit_size: Field, value: 15 }, Const { destination: Direct(32854), bit_size: Integer(U32), value: 20 }, Const { destination: Direct(32855), bit_size: Field, value: 20 }, Const { destination: Direct(32856), bit_size: Field, value: 22 }, Const { destination: Direct(32857), bit_size: Field, value: 30 }, Return, Call { location: 54 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 42 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32843) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 46 }, Call { location: 60 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, Mov { destination: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 63 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 59 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: 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(4) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 84 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 303 }, Jump { location: 87 }, Load { destination: Relative(3), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(4) }, 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: 95 }, Call { location: 326 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(5), location: 101 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 107 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Direct(32845) }, Mov { destination: Relative(9), source: Relative(4) }, Mov { destination: Relative(10), source: Relative(1) }, Mov { destination: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 329 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 124 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Direct(32845) }, Mov { destination: Relative(10), source: Relative(4) }, Mov { destination: Relative(11), source: Relative(1) }, Mov { destination: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 434 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 141 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Direct(32845) }, Mov { destination: Relative(11), source: Relative(4) }, Mov { destination: Relative(12), source: Relative(1) }, Mov { destination: Relative(13), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 530 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 158 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(10), location: 164 }, Call { location: 748 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, Mov { destination: Relative(15), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(10) }, Call { location: 751 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(3) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 179 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 866 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Field, value: 3 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Direct(32836) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32839) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32841) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32844) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Relative(11) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 915 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(3) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 218 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Direct(32845) }, Mov { destination: Relative(14), source: Relative(4) }, Mov { destination: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 959 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 234 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 13 }, Mov { destination: Relative(13), source: Direct(0) }, Mov { destination: Relative(14), source: Direct(32845) }, Mov { destination: Relative(15), source: Relative(4) }, Mov { destination: Relative(16), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1013 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 14 }, Mov { destination: Relative(14), source: Direct(0) }, Mov { destination: Relative(15), source: Direct(32845) }, Mov { destination: Relative(16), source: Relative(4) }, Mov { destination: Relative(17), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1414 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 266 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 15 }, Mov { destination: Relative(15), source: Direct(0) }, Mov { destination: Relative(16), source: Direct(32845) }, Mov { destination: Relative(17), source: Relative(4) }, Mov { destination: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1549 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 282 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1750 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 2024 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Load { destination: Relative(4), source_pointer: Relative(5) }, Load { destination: Relative(7), source_pointer: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(7) }, 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: 311 }, Call { location: 326 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Store { destination_pointer: Relative(6), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 84 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 335 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 343 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 346 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 354 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 370 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 373 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 379 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 391 }, Jump { location: 382 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 414 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 402 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 405 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 414 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32842), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 418 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32841) }, JumpIf { condition: Relative(4), location: 424 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 427 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 433 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 440 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 448 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 451 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 459 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 475 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 478 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 484 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, JumpIf { condition: Relative(2), location: 496 }, Jump { location: 487 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 519 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 507 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 510 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 519 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 523 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 529 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 538 }, Call { location: 2285 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 546 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 549 }, Call { location: 2285 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 557 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 574 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 577 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 583 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 596 }, Jump { location: 586 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Jump { location: 675 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(7), location: 618 }, Jump { location: 608 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 675 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 658 }, Jump { location: 621 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 634 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 651 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 657 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 663 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Direct(32841), rhs: Direct(32856) }, JumpIf { condition: Relative(1), location: 662 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 663 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 668 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 674 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 675 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 680 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32852) }, JumpIf { condition: Relative(4), location: 686 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 692 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 698 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 704 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(7), location: 712 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 718 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 735 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 741 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 747 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 757 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 765 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 768 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32841) }, JumpIf { condition: Relative(7), location: 776 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 792 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 795 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 801 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 814 }, Jump { location: 805 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(4), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Jump { location: 856 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(2), location: 847 }, Jump { location: 825 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32843) }, JumpIf { condition: Relative(2), location: 828 }, Jump { location: 837 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32846) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 837 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 840 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 846 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 856 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 856 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 859 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 865 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 885 }, Jump { location: 874 }, JumpIf { condition: Relative(6), location: 876 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 884 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 904 }, JumpIf { condition: Relative(6), location: 887 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 895 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 904 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 908 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 914 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 933 }, Jump { location: 923 }, JumpIf { condition: Relative(5), location: 925 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(4), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 932 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 951 }, JumpIf { condition: Relative(5), location: 935 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(4), rhs: Direct(32844) }, JumpIf { condition: Relative(5), location: 942 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2314 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Store { destination_pointer: Relative(6), source: Direct(32841) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 951 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32841) }, JumpIf { condition: Relative(1), location: 958 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 991 }, Jump { location: 967 }, JumpIf { condition: Relative(6), location: 969 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 977 }, 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: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Sub, lhs: Relative(5), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 1002 }, JumpIf { condition: Relative(6), location: 993 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 1001 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 1002 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1006 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 1012 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1052 }, Jump { location: 1024 }, JumpIf { condition: Relative(7), location: 1026 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(3), location: 1034 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1040 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1393 }, JumpIf { condition: Relative(7), location: 1054 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1062 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1075 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1087 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(8) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Load { destination: Relative(6), source_pointer: Relative(1) }, 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: 1100 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1106 }, Call { location: 60 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1109 }, Call { location: 2285 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(9), rhs: Direct(32852) }, JumpIf { condition: Relative(6), location: 1117 }, 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(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1123 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1129 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Load { destination: Relative(2), source_pointer: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1149 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(2), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2336 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 1162 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32842) }, Load { destination: Relative(1), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(12), location: 1168 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1174 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1180 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(10), location: 1186 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1192 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2336 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Store { destination_pointer: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 1205 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, Load { destination: Relative(11), source_pointer: Relative(14) }, BinaryFieldOp { destination: Relative(14), op: Equals, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(14), location: 1211 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1217 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, JumpIf { condition: Relative(11), location: 1223 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32850) }, Load { destination: Relative(11), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(11), rhs: Direct(32857) }, JumpIf { condition: Relative(12), location: 1229 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1235 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Load { destination: Relative(16), source_pointer: Relative(17) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(16), rhs: Direct(32852) }, JumpIf { condition: Relative(13), location: 1256 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1262 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(13), location: 1268 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(20) }, Load { destination: Relative(13), source_pointer: Relative(19) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2428 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1280 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(18) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1286 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1292 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Direct(32840), rhs: Relative(3) }, JumpIf { condition: Relative(11), location: 1296 }, Call { location: 60 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(11), location: 1299 }, Call { location: 2285 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(19), rhs: Relative(1) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Mov { destination: Direct(32772), source: Relative(19) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2470 }, Mov { destination: Relative(15), source: Direct(32774) }, Mov { destination: Relative(20), source: Direct(32775) }, Store { destination_pointer: Relative(20), source: Direct(32855) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1312 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32845) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(18), location: 1318 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32847), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1321 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(18), location: 1327 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1333 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1339 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1345 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(19), location: 1351 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(3), location: 1354 }, Call { location: 2285 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(20) }, Load { destination: Relative(21), source_pointer: Relative(22) }, Mov { destination: Direct(32771), source: Relative(15) }, Mov { destination: Direct(32772), source: Relative(20) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2539 }, Mov { destination: Relative(19), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1372 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(19) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(1), location: 1380 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 1386 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1392 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Jump { location: 1393 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1401 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1407 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(2), location: 1413 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1465 }, Jump { location: 1425 }, JumpIf { condition: Relative(7), location: 1427 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1435 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1453 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1485 }, JumpIf { condition: Relative(7), location: 1467 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1475 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1485 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1493 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1499 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1505 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(7), location: 1513 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1519 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1536 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 1542 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 1548 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1600 }, Jump { location: 1560 }, JumpIf { condition: Relative(7), location: 1562 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1570 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1588 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 1620 }, JumpIf { condition: Relative(7), location: 1602 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1610 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1620 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1628 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1634 }, 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(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1640 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 1648 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1651 }, Jump { location: 1671 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1659 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1671 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1679 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1694 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1700 }, 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(7) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1706 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(8), location: 1714 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1720 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(9) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1737 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, JumpIf { condition: Relative(4), location: 1743 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(1), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(4), location: 1749 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Cast { destination: Relative(9), source: Relative(3), bit_size: Field }, Const { destination: Relative(10), bit_size: Field, value: 50 }, JumpIf { condition: Relative(7), location: 1806 }, Jump { location: 1763 }, JumpIf { condition: Relative(8), location: 1765 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1778 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(2) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1794 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1838 }, JumpIf { condition: Relative(8), location: 1808 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(4), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1826 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 1838 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1846 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1863 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32849) }, JumpIf { condition: Relative(1), location: 1869 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1872 }, Jump { location: 1890 }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1878 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1890 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, 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: 1898 }, Call { location: 326 }, 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(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Store { destination_pointer: Relative(6), source: Relative(9) }, JumpIf { condition: Relative(1), location: 1929 }, Jump { location: 1911 }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 1917 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 1929 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1937 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1955 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1962 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1965 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(5), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 1973 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 1979 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(3), rhs: Direct(32857) }, JumpIf { condition: Relative(6), location: 1987 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1993 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32853) }, JumpIf { condition: Relative(1), location: 2001 }, 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(9) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2007 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 2016 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 2023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(9), source: Relative(4), bit_size: Field }, JumpIf { condition: Relative(7), location: 2126 }, Jump { location: 2036 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 2039 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32846) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2052 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(10) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 2067 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(2) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2082 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 2088 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2094 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(12), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(12) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(14) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 2109 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 2117 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 2123 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 2144 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2132 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Jump { location: 2144 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2152 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2169 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 2175 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 2178 }, Jump { location: 2196 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2184 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 2196 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2211 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Direct(32857) }, JumpIf { condition: Relative(1), location: 2217 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 2228 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2240 }, Jump { location: 2257 }, JumpIf { condition: Direct(32781), location: 2242 }, Jump { location: 2246 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2256 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2256 }, Jump { location: 2269 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2269 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2283 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2283 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2276 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2292 }, Jump { location: 2294 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2313 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2311 }, 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: 2304 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2313 }, 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: 2318 }, Jump { location: 2320 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2335 }, 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: 2332 }, 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: 2325 }, 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: 2335 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2347 }, Jump { location: 2364 }, JumpIf { condition: Direct(32781), location: 2349 }, Jump { location: 2353 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2363 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2363 }, Jump { location: 2376 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2376 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2389 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2382 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2400 }, Jump { location: 2404 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2426 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2425 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2418 }, Jump { location: 2426 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2438 }, Jump { location: 2446 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2469 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2468 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2461 }, Jump { location: 2469 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2481 }, Jump { location: 2498 }, JumpIf { condition: Direct(32782), location: 2483 }, Jump { location: 2487 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2497 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2497 }, Jump { location: 2510 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2510 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2524 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2524 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2517 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2538 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2531 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2548 }, Jump { location: 2554 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2576 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2575 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2568 }, Jump { location: 2576 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2591 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2584 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32859 }, 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(32858), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32858) }, Call { location: 13 }, Call { location: 37 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32859 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Field, 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: Field, value: 1 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32841), bit_size: Field, value: 2 }, Const { destination: Direct(32842), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32843), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32844), bit_size: Field, value: 4 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32846), bit_size: Field, value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 10 }, Const { destination: Direct(32852), bit_size: Field, value: 10 }, Const { destination: Direct(32853), bit_size: Field, value: 15 }, Const { destination: Direct(32854), bit_size: Integer(U32), value: 20 }, Const { destination: Direct(32855), bit_size: Field, value: 20 }, Const { destination: Direct(32856), bit_size: Field, value: 22 }, Const { destination: Direct(32857), bit_size: Field, value: 30 }, Return, Call { location: 54 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 42 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32843) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 46 }, Call { location: 60 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, Mov { destination: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 63 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 59 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: 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(4) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 84 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 303 }, Jump { location: 87 }, Load { destination: Relative(3), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(4) }, 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: 95 }, Call { location: 326 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(5), location: 101 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 107 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Direct(32845) }, Mov { destination: Relative(9), source: Relative(4) }, Mov { destination: Relative(10), source: Relative(1) }, Mov { destination: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 329 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 124 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Direct(32845) }, Mov { destination: Relative(10), source: Relative(4) }, Mov { destination: Relative(11), source: Relative(1) }, Mov { destination: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 434 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 141 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Direct(32845) }, Mov { destination: Relative(11), source: Relative(4) }, Mov { destination: Relative(12), source: Relative(1) }, Mov { destination: Relative(13), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 530 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 158 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(10), location: 164 }, Call { location: 737 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, Mov { destination: Relative(15), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(10) }, Call { location: 740 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(3) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 179 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 855 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Field, value: 3 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Direct(32836) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32839) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32841) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32844) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Relative(11) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 904 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(3) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 218 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Direct(32845) }, Mov { destination: Relative(14), source: Relative(4) }, Mov { destination: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 948 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 234 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 13 }, Mov { destination: Relative(13), source: Direct(0) }, Mov { destination: Relative(14), source: Direct(32845) }, Mov { destination: Relative(15), source: Relative(4) }, Mov { destination: Relative(16), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1002 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 14 }, Mov { destination: Relative(14), source: Direct(0) }, Mov { destination: Relative(15), source: Direct(32845) }, Mov { destination: Relative(16), source: Relative(4) }, Mov { destination: Relative(17), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1403 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 266 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 15 }, Mov { destination: Relative(15), source: Direct(0) }, Mov { destination: Relative(16), source: Direct(32845) }, Mov { destination: Relative(17), source: Relative(4) }, Mov { destination: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1538 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 282 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1739 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 2013 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Load { destination: Relative(4), source_pointer: Relative(5) }, Load { destination: Relative(7), source_pointer: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(7) }, 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: 311 }, Call { location: 326 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Store { destination_pointer: Relative(6), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 84 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 335 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 343 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 346 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 354 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 370 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 373 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 379 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 391 }, Jump { location: 382 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 414 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 402 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 405 }, Call { location: 2274 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 414 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32842), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 418 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32841) }, JumpIf { condition: Relative(4), location: 424 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 427 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 433 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 440 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 448 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 451 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 459 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 475 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 478 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 484 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, JumpIf { condition: Relative(2), location: 496 }, Jump { location: 487 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 519 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 507 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 510 }, Call { location: 2274 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 519 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 523 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 529 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 538 }, Call { location: 2274 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 546 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 549 }, Call { location: 2274 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 557 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 574 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 577 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 583 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 596 }, Jump { location: 586 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Jump { location: 664 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(7), location: 618 }, Jump { location: 608 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 664 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 658 }, Jump { location: 621 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 634 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 651 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 657 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 663 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Direct(32841), rhs: Direct(32856) }, JumpIf { condition: Relative(1), location: 662 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 663 }, Jump { location: 664 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 669 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32852) }, JumpIf { condition: Relative(4), location: 675 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 681 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 687 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 693 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(7), location: 701 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 707 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 724 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 730 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 736 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 746 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 754 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 757 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32841) }, JumpIf { condition: Relative(7), location: 765 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 781 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 784 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 790 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 803 }, Jump { location: 794 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(4), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Jump { location: 845 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(2), location: 836 }, Jump { location: 814 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32843) }, JumpIf { condition: Relative(2), location: 817 }, Jump { location: 826 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32846) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 826 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 829 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 835 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 845 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 845 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 848 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 854 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 874 }, Jump { location: 863 }, JumpIf { condition: Relative(6), location: 865 }, Call { location: 2274 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 873 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 893 }, JumpIf { condition: Relative(6), location: 876 }, Call { location: 2274 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 884 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 893 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 897 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 903 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 922 }, Jump { location: 912 }, JumpIf { condition: Relative(5), location: 914 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(4), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 921 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 940 }, JumpIf { condition: Relative(5), location: 924 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(4), rhs: Direct(32844) }, JumpIf { condition: Relative(5), location: 931 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2303 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Store { destination_pointer: Relative(6), source: Direct(32841) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 940 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32841) }, JumpIf { condition: Relative(1), location: 947 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 980 }, Jump { location: 956 }, JumpIf { condition: Relative(6), location: 958 }, Call { location: 2274 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 966 }, 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: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Sub, lhs: Relative(5), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 991 }, JumpIf { condition: Relative(6), location: 982 }, Call { location: 2274 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 990 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 991 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 995 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 1001 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1041 }, Jump { location: 1013 }, JumpIf { condition: Relative(7), location: 1015 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(3), location: 1023 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1029 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1382 }, JumpIf { condition: Relative(7), location: 1043 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1051 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1064 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1076 }, Call { location: 2274 }, Mov { destination: Direct(32771), source: Relative(8) }, Call { location: 2277 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Load { destination: Relative(6), source_pointer: Relative(1) }, 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: 1089 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1095 }, Call { location: 60 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1098 }, Call { location: 2274 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(9), rhs: Direct(32852) }, JumpIf { condition: Relative(6), location: 1106 }, 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(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1112 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1118 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Load { destination: Relative(2), source_pointer: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1138 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(2), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2325 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 1151 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32842) }, Load { destination: Relative(1), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(12), location: 1157 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1163 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1169 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(10), location: 1175 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1181 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2325 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Store { destination_pointer: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 1194 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, Load { destination: Relative(11), source_pointer: Relative(14) }, BinaryFieldOp { destination: Relative(14), op: Equals, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(14), location: 1200 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1206 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, JumpIf { condition: Relative(11), location: 1212 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32850) }, Load { destination: Relative(11), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(11), rhs: Direct(32857) }, JumpIf { condition: Relative(12), location: 1218 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1224 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2380 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Load { destination: Relative(16), source_pointer: Relative(17) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1239 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(16), rhs: Direct(32852) }, JumpIf { condition: Relative(13), location: 1245 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1251 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(13), location: 1257 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(20) }, Load { destination: Relative(13), source_pointer: Relative(19) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2417 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1269 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(18) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1275 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1281 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Direct(32840), rhs: Relative(3) }, JumpIf { condition: Relative(11), location: 1285 }, Call { location: 60 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(11), location: 1288 }, Call { location: 2274 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(19), rhs: Relative(1) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Mov { destination: Direct(32772), source: Relative(19) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2459 }, Mov { destination: Relative(15), source: Direct(32774) }, Mov { destination: Relative(20), source: Direct(32775) }, Store { destination_pointer: Relative(20), source: Direct(32855) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1301 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32845) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(18), location: 1307 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32847), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1310 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(18), location: 1316 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1322 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1328 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1334 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(19), location: 1340 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(3), location: 1343 }, Call { location: 2274 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(20) }, Load { destination: Relative(21), source_pointer: Relative(22) }, Mov { destination: Direct(32771), source: Relative(15) }, Mov { destination: Direct(32772), source: Relative(20) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2528 }, Mov { destination: Relative(19), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1361 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(19) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(1), location: 1369 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 1375 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1381 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Jump { location: 1382 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1390 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1396 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(2), location: 1402 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1454 }, Jump { location: 1414 }, JumpIf { condition: Relative(7), location: 1416 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1424 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1442 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1474 }, JumpIf { condition: Relative(7), location: 1456 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1464 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1474 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1482 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1488 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1494 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(7), location: 1502 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1508 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1525 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 1531 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 1537 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1589 }, Jump { location: 1549 }, JumpIf { condition: Relative(7), location: 1551 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1559 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1577 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 1609 }, JumpIf { condition: Relative(7), location: 1591 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1599 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1609 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1617 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1623 }, 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(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1629 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 1637 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1640 }, Jump { location: 1660 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1648 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1660 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1668 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1683 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1689 }, 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(7) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1695 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(8), location: 1703 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1709 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(9) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1726 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, JumpIf { condition: Relative(4), location: 1732 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(1), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(4), location: 1738 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Cast { destination: Relative(9), source: Relative(3), bit_size: Field }, Const { destination: Relative(10), bit_size: Field, value: 50 }, JumpIf { condition: Relative(7), location: 1795 }, Jump { location: 1752 }, JumpIf { condition: Relative(8), location: 1754 }, Call { location: 2274 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1767 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(2) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1783 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1827 }, JumpIf { condition: Relative(8), location: 1797 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(4), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1815 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 1827 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1835 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1852 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32849) }, JumpIf { condition: Relative(1), location: 1858 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1861 }, Jump { location: 1879 }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1867 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1879 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, 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: 1887 }, Call { location: 326 }, 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(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Store { destination_pointer: Relative(6), source: Relative(9) }, JumpIf { condition: Relative(1), location: 1918 }, Jump { location: 1900 }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 1906 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 1918 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1926 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1944 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1951 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1954 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(5), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 1962 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 1968 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(3), rhs: Direct(32857) }, JumpIf { condition: Relative(6), location: 1976 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1982 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32853) }, JumpIf { condition: Relative(1), location: 1990 }, 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(9) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1996 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 2005 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 2012 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(9), source: Relative(4), bit_size: Field }, JumpIf { condition: Relative(7), location: 2115 }, Jump { location: 2025 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 2028 }, Call { location: 2274 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32846) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2041 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(10) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 2056 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(2) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2071 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 2077 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2083 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2380 }, Mov { destination: Relative(12), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(12) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(14) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 2098 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 2106 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 2112 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 2133 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2121 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Jump { location: 2133 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2141 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2158 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 2164 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 2167 }, Jump { location: 2185 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2173 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 2185 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2380 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2200 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Direct(32857) }, JumpIf { condition: Relative(1), location: 2206 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2380 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 2217 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2229 }, Jump { location: 2246 }, JumpIf { condition: Direct(32781), location: 2231 }, Jump { location: 2235 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2245 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2245 }, Jump { location: 2258 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2258 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2272 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2272 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2265 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2281 }, Jump { location: 2283 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2302 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2300 }, 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: 2293 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2302 }, 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: 2307 }, Jump { location: 2309 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2324 }, 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: 2321 }, 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: 2314 }, 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: 2324 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2336 }, Jump { location: 2353 }, JumpIf { condition: Direct(32781), location: 2338 }, Jump { location: 2342 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2352 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2352 }, Jump { location: 2365 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2365 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2378 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2371 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2389 }, Jump { location: 2393 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2415 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2414 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2407 }, Jump { location: 2415 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2427 }, Jump { location: 2435 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2458 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2457 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2450 }, Jump { location: 2458 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2470 }, Jump { location: 2487 }, JumpIf { condition: Direct(32782), location: 2472 }, Jump { location: 2476 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2486 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2486 }, Jump { location: 2499 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2499 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2513 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2513 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2506 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2527 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2520 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2537 }, Jump { location: 2543 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2565 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2564 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2557 }, Jump { location: 2565 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2580 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2573 }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "pd3RruU2ziXgd6nrXFikSEl5laARpLvTjQCFdCN/MsAgyLuPuSRy1RlggIHOTfSdqtqkLZuyLWuf/Pnlnz///Y9///jLr//6z/98+f6HP7/8/bdfvn795d8/fv3PP376/Zf//Pr+6Z9fnviPzi/ft+++6ELTn9203ciX7+VtdDd9N7Yb//K9vs3YzdzNQmPPbtpuBI333dhu9sd9f9z3x31/fOyPj/3xsT8+dDc7ythRxo4ydpSxo4wdZe4oc0eZ7+f627z/0t5m7mahWc9u2m5kN7qbvhvbje/mjeJvM3ez0LTnOW07rZxWT9tPa6f1047TztO+8cbbtue07bRyWj1tP62d1k87TjtPe+LJiScnnpx4cuLJiScnnrzxZrTjtPO0a7f6nLadVk6rp+2ntdOeeHri6YmnJ14/8fqJ10+8OP1WtP20dlo/7TjtPO3abZyFaNtp5bQnnp14duLZiWcnnp14duJ51MYTaAlJaOKN2VrAEp4YiZlYB3HCb7SEJDSRkUdGHhl5ZOSRkUdGnhk5yqBJQBKa6AlLeGIkZiIiv/XUomg2WkISmugJS3hiJGbiRJbnSbSEJDTRExG5BzwxEjOxDqKiNlpCEproiYzcMnLLyC0jt4wctdUs0BKS0ERPWMITIzET60AzsmZkzciakTUja0aOWmseGImZWAcY64GWkIQmesISGbln5J6Re0a2jGwZOWqvjYAmesISnhiJmVgHqEGgJTKyZ2TPyJ6RPSN7RkYNzsA6QA0CLSEJTfSEJTwxEhl5ZOSZkWdGnhl5ZmTU4ApYwhMjMRPrADUItIQk4pr9BHrCEp4YiZlYGxo1uNESiguoPv20dlo/7TjtPO3abdQc2nZaOW1sYNx4tH2F1Wan9dOO087T7ou1ynPadlo57b5gaxSMSKAlJKGJnohO0YAnRmImolNik6NgNlpCEproCUtE5NiwKJiNmVgHUTDigZaQhCYi8ghYwhMjMRPrIApmoyUi8gxooicsEZFXYCRmYh3gLi3ODNynAZKIe7U4trhbA+J+LTocd2zASMxE3LdFh0d5aHRdlMdGT1jCEyMxE+sgqkKje6MqNjTRE5bwxEhEwOj5qIpAj6rYaImIPAKa6ImIPAOeGImZWAdRJRstIYmz7z0KRFfAEyMRRfcE1kFUScctfEtIQhNRynErHxekDU9ENccNfVyQNiJybEbU10ZLSCLiWMATIzET6yCqqUcfRjVtSEITsYXRmVFNG54YiZlYB1FNGxE5+jCqaUMTPRGRow+jmjZGYiZi6IlejWraaAlJaKInLOGJGNKi56OaNtZBVNNGRI5DENW0oYmeiMh4+PLESETkOBZRTUBcfiw6PC4/G5LQRESODsfzUXQdnpCAdYCnJKAlJKGJnogNi+6NatqYibVhUU0bLSGJCLgCPWEJT8Rj0xOYiXUQ1eQt0BKS0ERPWMITI3H23aKaXAItIYkIiKfcnrB9cbGopo2RmAdRO94DktBET1jCEyMRu2yBdRDVtNESEdkDmugJS3hiJGYiIse+RzVttIQkInIcr6imDUt4IiLH8Ypq2lgHUU0bLSEJTfSEJeIxN45yVNPGTKyDqKYRRzCqaUMSmojH3TgWUU0bnojIcSijmjYicvR8VNNGS0giIkfPx7VpRB9GNW3MxDqIatpoCUlooiciYHR4VNPGTKwNj2raaAlJaKInYpdnIOKswDrArAPQEpLQRE9YwhPxUP8eAo9KmS0gCU30hCU8MRIzsQ4w3QBkZM3ImpE1I2tGxqSDBEZiJtYBJh6AlpCEJnrCEhm5Z+SekXtGtoxsGdkyctTOxHxYT1jCExGwB9ZBlMxGS5yTxKNANuLjFhiJmYg48W+iQDYiTpwSUSAbmugJS3hiJGZiHUSBbGTkmZGjQGacdXG52bCEJ0ZiJtZBlMxGS0giI6+MHPd1M07IqJ2NmNaJMzNqZ2NtjKidjZaQhCZ6whKeGImZiMgtpjCfREtIQhM9YQlPjMRMZGTJyJKRJSNLRpaMLBk5Cm1JYCRmYh1EoS3MuLaE7Hu2EYW20RPnlm9E7awekIQmesISsRn41EjMxDrA9J0HWkISmugJS3giIo/ATKyDKKKNiDwDktBET0TkFfDESMzEOoiy2mgJSWCKME4OzCJsWclL8bj/xLHCTMLWSmEuYQuTkHG8MJuwpSXkwJy4lZAjuh9TCluztFKYVXjiEGBa4YnexEzeE32GqbwtL43SLK2jifm8rVbCls5QL1nJS6M0SyuF+bwtRF4hzJM+IUyLttAsrRRm7LZaSUpa6iUvjdMvE/N1W4j89v3EjN0WIsfbB8zZbWmplxA5Xk9gum5rllYKM3ZbrSQlLeUxmpitixnBiem6LUSObcaEHYSbvPiotYQkNIFYERUTdFuzhFhxLDBHF5NQE1NyW72ESeY4PpiV2xqlWYp4MUE0MTO31UpS6pl3T4xDiBxHANW0NUsrhWqKOZ65p8chKWmpth7VtOWlUZqllVrVG6imLc2tR13FNNFEXW15CVuPF1WztPYYunDRAlpCEogVr6ZQSVujhFgjhJ6Y8epLSlrCtq2QlbyECfwnNEsrheraksyGmtrC7H0LWclLiCyhWVopVNdWyy3V2nqtrUd1bVnJS6M0U722GdUVU1EL1bWl50xfmBPfspKXsKVxFDALvtVKiIcXiniVEccDdbU1StjziIe6glBXW62EeLH1qLWtXrIScsRxQ61tzdJKodZiAmmh1mKaaKHWtrTUS1by0ijNFGoNe45a20LkOJaota1eslL10KweQq1trdSqbcY8eMxbLdTaVi8hchwP1NpW1ceuNWgdvZfmh0REAztppJODnCReG+13xejwASrZScSdoJODnCTiLrx7fshGCqlkJ410cpCTZDZltv2a6gGFVLKTRjo5yEmuIspzdx/q8xApGthJI51ECgEnuYqo3UPskIJCKtlJI50c5CRXEZV9yGzObM5szmzObKjvmO57OchJriJq/LCRQiIbzlTU+aGRyLbXLgxykquIuj9spJBKdtJIZpvMNpltMttiNgwGhhrCaHCoZCeNdHKQyIYiw6AAYsVHspHItkAlO2mkk4Oc5CpiqDhsJLM1ZsMAEnOhDctDkk4OEu9vG7iKGEAOGymkkp1ENgGdHOQkVxEDyGEjhVSyk8ymzKbMpsymzLbffCvYSCGV7KSRTg4S2Tq4ivtt+CayGSgksjnYSSOdHOQkVxFjyWEjhWQ2ZzaMJb6XETk5yEkiG851jCWHyIazD2PJoZKdNNLJQU5yFTGWHDLbZDaMJQNnNcaSQyOdHOQkVxFjySFWG+AEx1hyqCSy4eTCWHKIbDg1MJYcTnIl96qXw0YKqWQnjXRykMjWwVXEWHLYSGQzUElkc9BIJwc5yVXEWHLYSCGVZDZhNowlY69aG+QkVxFjyWEjhVSyk0YymzKbMpsyW2c2jCUDS+Qwlhwq2UkjnRzkJFcRY8khsxmz7fU1C+ykkU5izcoDTnIVMZYcNlJIJTuJ1TENdHKQk1zFvQJns5FCKtlJZhvMttfjCDjJVdyrcjaRDdWyV+ZsKtlJZEO1YCw5HOQkVxFjyWEjhVSyk8y2mG0xG8aSiTLFWAJi9U4S2RwUEtkG2EkjnUS2veBzkquIsSSm2BsW+SSxEukBleykkU4OcpKriLHksJHMJsyGsSTmvV8a6eQgJ7mKGEsOGymkksymzIaxJObVG5YWJSe5ihhLYsa9YYlRUkglO2mkk4Oc5CoasxmzGbMZsxmzGbMZsxmzGbMZszmzObM5szmzObNhLIlJrYZFSclBTnIVMZYcNlJIJTvJbIPZ9nQGimHPZ2yu4nzIeubVqWQnjXRykJOsZ17dDzabjcQOodAxgBx20kjsEMofA8ghplGwmytnrlp/HrKRiDtAI50c5CRXEUPF2ou8cViwXnsPCptGYpniAw5ykqsoWK7YwEYKqSQWRApopJODRDYFkQ39gBWGh40UUslOGunkICfJbJ3ZOrN1ZuvMhtWH8eqmYcVU0slBTnIVsRLxsJFC9jqEeyTYRAoHBznJVcSSxAfnAxYlHgqpJE8N56mxR4LNQU5yFfdIsMlTbo8Em+yzwT4b7LPBPhvss8E+m+yzyT6b7LOpJLKhz6aRTg5ykqu4HrKRQirJbIvZ9gJg7PxeArwZ2fAlBizR2sQirWQjhVSyk0Y6OchJMltDtgY2UkglO2mkk4Oc5CoKswmzCbMJswmzCbMJs2HUwFck9iqvw1XEqHGIbAoKWfPKWAOWNNJJxI2ax8qvZCOFVLKT2AsEw/gQrwEbVn0dYiQ4RNwBCqlkJxF3gk4OcpLIFmcf1oIlGykk1m7jLMF6ZUGvY8XyoZODnOQqjodspJBKMttgtsFsg9kGs2F8EBxujA+HjRRSyU4a6eQgVx1CDAqHSIEzCoPCoZKdRAqcDxgUDgc5yTo1/HnIRgqpZCeNdHKQ1WdYhpZspJBKdtJIJwc5SWSLPnOMBIeNFFLJThrp5CAnyWzKbPs7Ctj5/S2FTWQbYCeNdBLZopywji3ZSCGV7KSRTn4Td5KriPEhXgU3rG5LCqlkJ410cpCz6EzhTOFM4UzhTOFM4UzhTOHfpFhFDAqKb/FhUDgUUslOGunkICe5ipPZJrNNZpvMNpkNg0K8Jm9YM5cc5CRXEePDYSOFVLKTzLaYDeODooYwPhwiWwwrWE+XbKSQSnbSSCcHOUlma8yGoQIPK1hnl1Syk0Y6OchJriKGikNmE2YTZhNmE2YTZhNmw1ARb8UbVuIdYqg4bCSyOahkPZ4NNdLJejwbGCp0s5FCKtlJI7EXE8ReLDD2ItYPNKzWO3+KkeAwgsUr+oY1e0knBznJVcSgcNhIIZVkNmc2ZzZnNmc2DAqx8qBhRZ90nFwYFA6FVLKTRjo5yEmu4mS2yWyT2SazTWbDoNBxGmFQOBzkJFcRg8JhI4VUkikWU2AkwB0pVv4lVxJr/5JI4SBSDFDJThrp5CAnuYoYCQ4byWyN2RqzNWZrzIaRAOsqsH4wuYoYCQ4bKaSSnTSSKYQphCmUKZQplCmUKZQplClwp3CIbAuc5Cru7zduNlJIJTtppJPM1pmtM5sxmzGbMZsxG0YNTHlNjBqHTg4ysmGZx8T4cCikkp000slBfhM39sL2F+QfspFCKtlJI50cJFNMpphMMZliMsVkiskUkykmU2BQOES2GEuwXjHZSCGV7KSRTo4klisK1pdgwWJSSCU7aaSTg8ReGLiKGAkOGymkkp000kmmaEwhTCFMIUwhTCFMIUwhTIGR4BDZHFxFjASHjRRSyU4a6eQgmU2ZrTNbZ7bObJ3ZOrN1Ztvfeh7gICe5ihgJDhsppJLINkEjnRwksi1wFXH/cNhIIZXspJFODpLZnNkwPmCdDVZUJiMbFsxgTWWyk0Y6OchJriKGisNGMttkNgwVWA+DlZZJZEPFYqg4nOQqYqg4bKSQSnbSSGZbzIZbCSyYwQpMULACM4lsBgqpZCeRzUEnB4n5qB13FdtDNhLzqZCVvDRKs7RSGC9iAY1gRabEqhnBikyJxSuCtZcy9r91cpARNdabCNZeHmJkOGykkEp20kgnB8lsymyd2TqzdWbDyBDLXwTLMJNGOjnISa4iRobDRgrJbMZsxmzGbMZs+/ckKLiK+3clbDZSSCU7aaSTg2Q2Z7bBbIPZBrNhZBg47zAyHBrp5CAnuYoYGQ4bKSSzTWbDyDBQSBgZDgc5yVXEyHDYSCGV7CSzLWZbzLaYbVU2LMNMNlJIJTtppJODRDYHVxEjw2EjhVTSSCcHyRSNKYQphCmEKXBrEYuOBGsvk0Y6OchJruIeQDYbyRTKFMoUyhTKFMoUyhSdKTpT7FFjE9km2EkjnRzkJFdxjxqbjRSS2YzZjNmM2YzZjNmM2faoscBGCqlkZItFUoKllclJriLGh8NGCqkk42J8iDVQgqWVyUFOchUxPhw2UkglmWIyBQaFWFAlWE+ZXEUMCoeNFFLJThrpJLMtZluVDespk41ENgWV7KSRyNbBQU5yFTEoHDZSyJxPE2mdNBLzaeOvv777kr+k8cfff/v55/gdjd/81sYf/vzy359++/nX3798/+sfX79+9+V//fT1D/yj//nvT7+i/f2n396/fU+Gn3/959u+Af/1y9efQ399x08//++P4psc+PBbHvVx+///fDwC7M97u/l8vB08n5eLz+MmG5+Xq/yopP35ZRefV8n9136z/WqZX+e6+Xws+MHnu/rF53tMfe7Pr3nxeavjb1f9b7GY5Xz+pv/M8/x531RefN5r/983Zjeff7w+f9N/brn/79ucm8/X8X9fMFx8fsTLlP15v/r8yM+/M7IXn58t+29e5Z+V/52vuan/VfX73NRPvNTKAex9oXQT4XlyF95b2vbpCFd78ehTEXR+NsJVJcUX8SqC3W3DsIow9dMRrrYBv6NgR3ifJO4iSEW4qqmPEewqglQ/tLvzAXNiO4JcVXZrdWmOb+1cbUPjNsjV3Q3WP5wIV9fXhgVfuQ1Xx4JDVHwd4C7CwwjzkxH0uaosleoHvTsWGovOMoJ9NoLeVJZZPP+c25W76u7chn63F99GuNqLWDtcEUw+HeHqnOzOCONuG2ZVd7+ri28i2HO1DSY10ppc1YXVDVAsPP10hKtz0pT9cHc+eN2GxRKnq21YdT743bFw5TbcXbP4MBBL3q4iyOA2XB2L0R7eT1715Ic70pue9FYPFf7Ogdw8Vc4nz6g+r+6KP0QQuYqgXhF6/3SEdRXBGMHvtqGuOC/XZyOsq21YrdckwdX9ZF91V/xG8M9GkHYVQasf1tX5YDprskMve9JquuZ993wVYXEvrq569rQc5d6L3tVd0DOeijBujqZJPbGaXI1yJjVWm1zdgZh8czSvrjjGydP3GnxzNK3XXfHLq3OSd4N2dz/5IYJeHYverSLczQL2wQh3Z/U3EezqCcWsnhbN9OpYmNXTgV098358vrjZi1h7kBPaj171w6grr93NaH2IcHXttlFXXht3Y/WHCOsqAqe2h99tA4/mmOuzEa6uOO8JVRPs8+rabbOuvG8E/2yEq2u3zbp22929nLcaaV/eRagnVm9XT6w26+pv8+56sbzOyXW1Df7UWO2PtasIdfV/efXOotUV5z0W9tkIdzM5a9ZVb129+XN8xzyfkj7/nHU12mOR/R7t3wnXm6fFOerZf66r5+6l9by5+l2EOhbt7lh8EyEWD15F4HP3avOzEeTy2l1H87l6m/fh6i83eyFWo9x7W321Dfh90jtCu+pJaXyp/04nXdVFzbqLXF1xPkbwq72oO5BY6PTpCOvT48PVE6vUTG+XqyuO8BlH7tYoSK+X5O/+XJ2Tfc06qx//bISrJ1axmp98D8XnI9hVhJqvfoM9nz4WV+eD1f3Dy/bpMepqbtDrqtfHc3VGOSvLr668/an3er1dzdN2/IbjE+HqXu5jhKt5uVbP3b2tqzPKR127fdpnI9xtw6h7uZdXI+2onpRxtXpBllWEd5rwKkLNib0RrvphjRrl1tK7CNyGqyfWbyLo3b2cPrWo8H1Z3a8idC4LsrsIvirC1X2Utpqn1XZ1L6etnjf1rrqVM5xvhPHZCFfPvNpqDkTb1dyg4rel7AhydWf+McLVOk1hP7wXjKsIq84HWXd7UTPeb4T+yQh6V5vK2tS72lSrflB/Ph3hqi56Pevp3by99rpeaL+6XmgfXHq8rs5Jq7kgvZuvVuP5cPfWXr2eWNWvnpLUZ+2F340PXveTb7CrbRi1Xu7l1Rk16u2D3q3k/RDhauZfh42KcHdOjnoD8nJ9NsLdODlmVda4q4tZ8w86r54vdPbqyXn5dOD1nvdulrUL39rL1bPeh2f/q3HSR83L+d3bh658QtG7JxStJ/fen7vvSPSnIlyt8v8Qwa7e+/P95rsJn49wtSaHa/b63Zq9bjU32O1q7UHXUdugUz4d4aofjOek3VW3DUa4mvH+NoI/V8/+Xu9QuuvdLErd03a/Gqs/zsPc7MV7ycq9GO8Lrav3OLO+AnT3HTBXrVFO+12E6ge/Oyc/RLh6j+O9rhfe5fMRrq4XvdYFvcGu3k5yZbL3q9p0rZn/tyzapyPc9cNkP1zdw7hxG0ztsxGu5qvd6jnL78ZJt5qPeidZr76f5/W86a53EeqO1P3qKcm9ZjB8PPrpCFc9yScUH/3qm5J8OnjnW6/24tu7wau9mForSeZlZXEdqa92tQ5k1Vu5lzd3g++Vrq5Zd+95ffForruzmrOsvq7uo3wZ++HqPc54atZ93H1vcTwuFWE8n47QryIY9+JqlHsrurahXb2NGq2eL0a7encw2uA2XH3bbuB37O8IcvWcNUT4ZearMWrgF0GdCPMuQn0PZejdHanWjNY7DXN1LNQZYdxF4BnVr0bawbf2425V8McIV2d1Z2X1qyvOxwh3/bBqL+xqBuNDBLl7xtE6q+3qLcyHCFdvYb59zrKrO9Lh7Ae/izB5vZhXTwdT+esG7u4fxpDahru1zYPf8Hp5NdIOjvbjbrQfNWf+durVODmlRvt59cw75qyRdl59K3ksVvfyq/vJp9YVz/eV71WEeu5+b2lv7h/eM7m2oV3dDU78f79PhKtjMbm2ebarcXIKK+tutnlKvY2acnVWT+Gx+L/fkP7t/emnf/zy24/f/H6lP/+KWL/98tPfv/58fvzXH7/+45u//f1//zf/5u+//fL16y///vG/v/3nHz//84/ffo5I8XdfnvOfH9791u/kfdP7t+++SPwcv/Ds/UN5f+74+X0Wff9Q358N//6935F34ub92ePn+CbO2wvz/Xng7+fz/tz8/Xni7219Jybj/XnFzyZvPJvP+3P8UqofrH9nESx+LdUP7z2Ey9/+il3/Pw==", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap index 8e531d3e5db..915ac59b8e8 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2073 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2079 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2079 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2050 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2085 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2088 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 434 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 434 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 427 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 433 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 434 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 439 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 445 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 451 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 457 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 463 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 472 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 478 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 496 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 502 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 509 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 517 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 523 }, Call { location: 2170 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 539 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 547 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2088 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 563 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 567 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 573 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 586 }, Jump { location: 577 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 619 }, Jump { location: 597 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 600 }, Jump { location: 609 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 609 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 612 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 618 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 628 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 631 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 637 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 645 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 664 }, Jump { location: 653 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 663 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 683 }, JumpIf { condition: Relative(29), location: 666 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 674 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 683 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 687 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 693 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 722 }, Jump { location: 714 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 721 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 738 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 729 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2173 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 738 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 745 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 753 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 785 }, Jump { location: 761 }, JumpIf { condition: Relative(29), location: 763 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 771 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 796 }, JumpIf { condition: Relative(29), location: 787 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 795 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 796 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 800 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 806 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 814 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 854 }, Jump { location: 826 }, JumpIf { condition: Relative(29), location: 828 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 836 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 842 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1196 }, JumpIf { condition: Relative(29), location: 856 }, Call { location: 2085 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 864 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 877 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 889 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 902 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 908 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 911 }, Call { location: 2085 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 919 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 925 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 931 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 951 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 964 }, Call { location: 2085 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 971 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 977 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 983 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 989 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 995 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1008 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1014 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1020 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1026 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1032 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1038 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1053 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1059 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1065 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1071 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2287 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1083 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1089 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1095 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1099 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1102 }, Call { location: 2085 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2329 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1115 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1121 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1124 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1130 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1136 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1142 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1148 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1154 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1157 }, Call { location: 2085 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2398 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1175 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1183 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1189 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1195 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1196 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1204 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1210 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1216 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1224 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1275 }, Jump { location: 1235 }, JumpIf { condition: Relative(22), location: 1237 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1245 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1263 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1295 }, JumpIf { condition: Relative(22), location: 1277 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1285 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1295 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1303 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1309 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1315 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1323 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1329 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1346 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1352 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1358 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1366 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1417 }, Jump { location: 1377 }, JumpIf { condition: Relative(27), location: 1379 }, Call { location: 2085 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1387 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1405 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1437 }, JumpIf { condition: Relative(27), location: 1419 }, Call { location: 2085 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1427 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1437 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1445 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1451 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1457 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1465 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1469 }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1477 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1497 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1512 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1518 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1524 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1532 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1538 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1555 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1561 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1567 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1575 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1632 }, Jump { location: 1590 }, JumpIf { condition: Relative(22), location: 1592 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1605 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1620 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1664 }, JumpIf { condition: Relative(22), location: 1634 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1652 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1664 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1672 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1689 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1695 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1697 }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1703 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1723 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1754 }, Jump { location: 1736 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1742 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1754 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1762 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1780 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1790 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1798 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1804 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1812 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1818 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1826 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1832 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1841 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1848 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1948 }, Jump { location: 1858 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1861 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1874 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1889 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1904 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1910 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1916 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1931 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1939 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1945 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1966 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1954 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1966 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1974 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1991 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1997 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1999 }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2005 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2032 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2038 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2049 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2058 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2078 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2092 }, Jump { location: 2094 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2113 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2111 }, 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: 2104 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2113 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2125 }, Jump { location: 2142 }, JumpIf { condition: Direct(32781), location: 2127 }, Jump { location: 2131 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2141 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2141 }, Jump { location: 2154 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2154 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2168 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2168 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2161 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2177 }, Jump { location: 2179 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2194 }, 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: 2191 }, 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: 2184 }, 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: 2194 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2206 }, Jump { location: 2223 }, JumpIf { condition: Direct(32781), location: 2208 }, Jump { location: 2212 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2222 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2222 }, Jump { location: 2235 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2235 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2248 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2241 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2259 }, Jump { location: 2263 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2285 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2284 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2277 }, Jump { location: 2285 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2297 }, Jump { location: 2305 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2328 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2327 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2320 }, Jump { location: 2328 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2340 }, Jump { location: 2357 }, JumpIf { condition: Direct(32782), location: 2342 }, Jump { location: 2346 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2356 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2356 }, Jump { location: 2369 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2369 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2383 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2383 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2376 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2397 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2390 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2407 }, Jump { location: 2413 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2435 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2434 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2427 }, Jump { location: 2435 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2450 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2443 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2062 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2068 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2068 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2039 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2074 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2074 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2077 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2077 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2074 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2074 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2077 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2074 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2074 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 423 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 423 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Jump { location: 423 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 428 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 434 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 440 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 446 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 452 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 461 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 467 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 485 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 491 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 498 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 506 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 512 }, Call { location: 2159 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 517 }, Call { location: 2074 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 525 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2074 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2077 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 552 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 556 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 562 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 575 }, Jump { location: 566 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 617 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 608 }, Jump { location: 586 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 589 }, Jump { location: 598 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 598 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 601 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 607 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 617 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 617 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 620 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 626 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 634 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 653 }, Jump { location: 642 }, JumpIf { condition: Relative(29), location: 644 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 652 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 672 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 663 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 672 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 676 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 682 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 711 }, Jump { location: 703 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 710 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 727 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 718 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2162 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 727 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 734 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 742 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 774 }, Jump { location: 750 }, JumpIf { condition: Relative(29), location: 752 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 760 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 785 }, JumpIf { condition: Relative(29), location: 776 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 784 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 785 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 789 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 795 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 803 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 843 }, Jump { location: 815 }, JumpIf { condition: Relative(29), location: 817 }, Call { location: 2074 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 825 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 831 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1185 }, JumpIf { condition: Relative(29), location: 845 }, Call { location: 2074 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 853 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 866 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 878 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 891 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 897 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 900 }, Call { location: 2074 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 908 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 914 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 920 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2077 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 940 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2184 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 953 }, Call { location: 2074 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 960 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 966 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 972 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 978 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 984 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2184 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 997 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1003 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1009 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1015 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1021 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1027 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1042 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1048 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1054 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1060 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2276 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1072 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1078 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1084 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1088 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1091 }, Call { location: 2074 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2318 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1104 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1110 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1113 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1119 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1125 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1131 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1137 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1143 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1146 }, Call { location: 2074 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2387 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1164 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1172 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1178 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1184 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1185 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1193 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1199 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1205 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1213 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1264 }, Jump { location: 1224 }, JumpIf { condition: Relative(22), location: 1226 }, Call { location: 2074 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1234 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1252 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1284 }, JumpIf { condition: Relative(22), location: 1266 }, Call { location: 2074 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1274 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1284 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1292 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1298 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1304 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1312 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1318 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1335 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1341 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1347 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1355 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1406 }, Jump { location: 1366 }, JumpIf { condition: Relative(27), location: 1368 }, Call { location: 2074 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1376 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1394 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1426 }, JumpIf { condition: Relative(27), location: 1408 }, Call { location: 2074 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1416 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1426 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1434 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1440 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1446 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1454 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1458 }, Jump { location: 1478 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1466 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1478 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1486 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1501 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1507 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1513 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1521 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1527 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1544 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1550 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1556 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1564 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1621 }, Jump { location: 1579 }, JumpIf { condition: Relative(22), location: 1581 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1594 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1609 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1653 }, JumpIf { condition: Relative(22), location: 1623 }, Call { location: 2074 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1641 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1653 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1661 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1678 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1684 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1686 }, Jump { location: 1704 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1692 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1704 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1712 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1743 }, Jump { location: 1725 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1731 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1743 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1751 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1769 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1776 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1779 }, Call { location: 2074 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1793 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1801 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1807 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1815 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1821 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1830 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1837 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1937 }, Jump { location: 1847 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1850 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1863 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1878 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1893 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1899 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1905 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1920 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1928 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1934 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1955 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1943 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1955 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1963 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1980 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1986 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1988 }, Jump { location: 2006 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 1994 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2006 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2021 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2027 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2038 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2047 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2067 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2081 }, Jump { location: 2083 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2102 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2100 }, 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: 2093 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2102 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2114 }, Jump { location: 2131 }, JumpIf { condition: Direct(32781), location: 2116 }, Jump { location: 2120 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2130 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2130 }, Jump { location: 2143 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2143 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2157 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2157 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2150 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2166 }, Jump { location: 2168 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2183 }, 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: 2180 }, 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: 2173 }, 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: 2183 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2195 }, Jump { location: 2212 }, JumpIf { condition: Direct(32781), location: 2197 }, Jump { location: 2201 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2211 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2211 }, Jump { location: 2224 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2224 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2237 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2230 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2248 }, Jump { location: 2252 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2274 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2273 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2266 }, Jump { location: 2274 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2286 }, Jump { location: 2294 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2317 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2316 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2309 }, Jump { location: 2317 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2329 }, Jump { location: 2346 }, JumpIf { condition: Direct(32782), location: 2331 }, Jump { location: 2335 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2345 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2345 }, Jump { location: 2358 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2358 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2372 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2372 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2365 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2386 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2379 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2396 }, Jump { location: 2402 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2424 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2423 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2416 }, Jump { location: 2424 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2439 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2432 }, Return]" ], - "debug_symbols": "td3Rrt02rgbgd8l1LyxRJMV5lcGg6HQygwBBW2TaAxwUffdjUiL/9GI5qXbOTf3tJOunl2xp2bLW7u/v/vX+n7/95/sPP/375/+++9vff3/3z08fPn788J/vP/784w+/fvj5p/tPf393+X8av/tb++5dk7XRtZlrY7Hp9z/s96atTV8bWpuxNnfKuDeyNro2c20sNnStTVubvja0NmNtVgqtFFoptFJopYyVMlbKWCljpYz7BfzdO77/idybtjZ9bWhtxtrw2sja6NrMtbHYyJ2i96atTV8bWpuxNrw2sja6NnNtLDa6UnSl6J1i94bWZqwNr42sja6NH4Dr3trazmtv297eSe0+NJP2duwt763sre7t3FtbW/O8+7hZ29u+t7S3nkf3lvdW9lb3du6t591N364r0RI9QYmR4IQkNOHB7LCNdiVawpPFQYmR4IQnq0MTnjwdtuHn9UJLeLI5KHG/vF+OmbANP6EXWqInKDES9/5071J+Vi/MhG34ub3QEj3hgd0xEpyQhCeTYyZsw7tE9+b1TrHQE5QYCU5IQhP53r13dD8W3j8WesID/RB4L1nghCQ80A+K95YF2/Ae0/1YeJ9Z6AlK3Mmx5b2VvdW9nXtra+u9J7Ztb/ve0t7eeeRvy7vPgiQ0MRN3KMXgeCVaoifuYPJj4v1ogROS0MRM2EL3zkTkaImeoIQn++jqnWlBEprwZHbYhnemhZboCUqMBCc8WRyamAnb8M5E6miJnqCEJ08HJyThyeaYCR/wL/+guRIt0RM+8PsnVHxkxKeSJmbCNuKjI9ASPUEJ/wTy5vVetaCJmbAN71ULLeGB3vLeqxZGghOe7K3qvWphJjzZG9O710JL9AQlRoITksj37r1qeMt7r1poCQ/0lvdeteCB3vLerRYkoQnvrwHb8L610BI9QYmR4IQkNHEnsx9K718B718LLdETlBiJO5n9LXv/WtDETHgy+ZXIlWiJnqDESHDCk+NCRhMzYRvev5gdLdETlPBkcXBCEpqYCdvw/rXQEj3hyeoYCU5IwpOnYyZsw/vXgieboyco4ddNl4MTfu3UHJqYCdvw3iTdIQlNzIRtxGVboCV6ghIe6McirtwCmpgJ2/BOtNASPUEJf19xyek5fnS87yzYhvedhZboCUqMBCc80I+OdxDxQ+AdZKEnKDESnJCEJmbCNiyTLZMtky2TLZO9g4gfZe8gC5qYCVsY3kEWWqInKDESnJCEJmYik1smt0z2DiLmoMRIcMKvrS/HTNiG94uFzOmZ491Bm4MTkvDA7pgJDyS/l7gSLdETY52HgzjhgXEHoomZ8MD7TBj+ubPggeLoCUqMBCckoYmZsA3vMguZzJnsXUbVMRKckIQmZsI24u4n0BI9kcmSyXEf5Icy7oQCmvBkPxZxP+SIO6JAS/QEJUaCE5LQRCZrJsdVnp8JcZkX6AlKjAQnJKGJmbANy2TLZMtky2TLZMtky2TLZO9o008/72gO9o620BKe3B2UGAlPJockNDETPqpffvd7JVqiJygxEpyQhCZmwvd5+A31lWiJnvB9jpvukeCEJDTh+6wO2/Cut9ASnjwdlBgJTkhCEzPhyea3/VeiJXrC78b9DXofXOCEJPyu3I+O98EF2/A+uNASPUGJkfBkP5TeBxc0MROe7IfS++BCS/SEJ3uDex9c4IQkPNmnQ7wPLnhyzHdciZboCU/2lo+JCG9D72gLtuEdbaEleoISI+H74+3s/WthJmzD+9dCS/QEJfwW//KDEXMQV/MpmpgV6a5W6iUqjRKXpKQlS3nvsZj+aYnIJReVIne4uCQlLUUu+zTSVWqlXqLSKHFJSvuQSI9gn62iqxTBMVnVSxHsr6BR4pKUvAd5hehBAduIHhRoiZ6gxEhwQhIxEXW5ZslS3omaz0sJU2mUYlLLDwtLSUuzFHl+YOQqtVIvRbIfGOFSJPueipZmyVIayd7O2kq9RKXae+WSlLQ0S5aa1Rox3bdEufdrqi9mGrkkpUj2Y7mm/EKRbD4peZVaqZdi8s+PR3S2JS5JSUuzZFsanXKplXqJSqPEJSlpaZaiRvfp1KvUSpFHLi5JKfKGa5YsFd1yKfaUXVQapUgWl5S0NEuR7DO+0S+XWqmXqDRKXJJS7TNF8vTZ46sUyTGj3EtUGqVIbi4paWmWLBX9cqmVeolKoxQTxiEpaSmmjf1oRb9c6iXP88ktjR66xCUpRZ63RvTQJUtFD12KGn7coocuUWmUooYft+ihPlWl0UOXZslS0UOXWqmXqBTJfoyihy5Fcszxz5KloocuVQtZtVD00KVRqn2OfjniqcEs2dZcM/T+DGBN0Ydijr67qDRKXIoakaKlWbJU9MulVuolKo0Sl+JZwHBpaZYsFX11qZXifbBLSlqKFHFZKvrlUitFirqoNEpckpKWZslS0UOXWqlqjKoRPdSn4Gb00CUpaWmWLBU9dKmVeimSzcUlT/Yr+hn9cmmWLBWfoRzPklqpl6jkNXx+bUZfXZKSlmbJUtFXl1qpl6hUNbRqaNXQqqFVI/qqT9vN6KtLrdRLVBolLkUNP8Oi1y7NUtTwMyx67VIr9RKVRolLUtLSLGUNu65SK/USlaKGuLgkJS3NkqXWs7ZQ1FBXL1FplKLGdElJS7Nkqei/S63US1QaparRq0b0bp+atOjdS5aK3r3kNXzC0qJ3L1FplLgkJS15DZ/StOjdoejdS63US1QaJS5JSUtVY1QNrhpcNbhqxOevT0NZ9PMlLklJS7NkqejnS1Ejnvb2EpWixnBxSUpRw8+/6OdLlop+vtRKvUSlUeKSlKqGVo3o5z7PatHPl1qpl6KGn7HRz5eihp9N0c+XtDRLlop+vtRKvUSlUaoaVjWin/sMpUU/X7Kt+x73AhvYQQIH6JV8JvSmgAp6MZ/9vGnF6PI+A3qzgR0kcIAMCqjgBK3YUa2jWnR/n2G9SeAAGYxqa4GBglEt1g3EKLAYw8BmAztI4AAZFFBBVCNUiwHBJ19vNrCDBA6QQQEVnKAVGdUY1RjVGNUY1WJ88FnbmwIqOEErxiCx2cAOEjhAVBNUi7HCp4dvTtCKMVxsRrU4wWPA2CRwgAwKqOAEYxFI9IsYODYb2EECB8iggApOENUM1WIMmdELYxDZJHCAUS16SwwkmwpOMKp5b1nLcjYb2EECB8iggApOENUaqjVUi7HEp4fbWrCzOcCotpb4CBjVYi3PWrqzaMW1fGcxqsUqnxhLNgmMarH6J8aSzahmQQUnaMUYSzYb2EECB8ggqhGqxVjik8wtFgJtxliy2cAOEjhABgVUENUGqsVY4hPULRYIJTtIYFTrQQYFVHCCVoyxZLOBHSQQ1QTVBNUE1QTVBNUU1RTVFNUU1RTVFNUU1RTVFNViLLE412Ms2WxgBwkcIIMCKjhBVDNUi7FkRMexDhI4wLy3bM0UnGDeXrZ+XWADO0jgABmMNzSCCk7QijGA+LOKFguUktF8EiRwgAzGe6OgghO04ppJWGxgBwkcIIPx3tbKQQUnaMUYQDYbGO9tLTlkUMBYgBgLD2PF4KYVY9XgZixEbMEOEjhAX4rjzzparHVKKjjBqBbvOFYSXnGwYi3hZgcJHCCDAio4QSsKqgmqCaoJqgmqxYLDK86dWHK4qeAErRhLDzcb2EECo0SccipglNDgBK0Yq6U2o0ScBLFiapPAAeLUmDg11viwOEErrvFhsYE45WJ82ESbGdrM0GaGNrNqs1hKlWxgBwkcYFSzoIAKTtCK7QIb2EECB4hqDdVarMSNxbltgrEaN9blxrr3zQZ2kMABMiigghNENUK1WFDsj7RaLMVKEjhABgVUcIJWXGuNF1FtoNpAtYFqA9UGqg1Ui1HDn1O1WNm1GaPGZgOj2ggSGNXiLIlRY1NABeO016AV1wXGYgM7SOAAGRRQwXhvi1aMUWOzgR0kMN7bDCo4wciN0zOGis0GdjDWhMdJG0PFJoMCerW97HyCVvShIunVYkV5rCfrsYI8VpQlB8iggApO0JKxvizZwA4SOEAGBYxqIzhBK8aosdnADhI4QAajBAcnGCV84I9VaMkGdjBKaHCADApYp8boE7TiGioWG9hBAgfIINqM0GaENhtos4E2G2izgTYbaLOBNlvfS1iMalE4xodNK8b4sNnADhI4QAYFRDVGtbiq8MegLRa3Jb1aLOuPBW5JAgfo1WJ5fyx0S1oxRoLNBnaQwAEiV5Eb48PmBKOa981Y7pZsYAcJHCCDAiqIEoYShhKGEoYShhKGEoYShhIxKGxGtfUdlQtsYAcJHCCDAio4QVRrqNZQraFaQ7UYFGh9f4ZBARWcoBVjfNhsYAcJRLWOajE++OPqFivoklFNglaM8WGzgR0kcIAMCqggqhGqxVDhD6BbrK5LdpDAATIooIITtCKjGqMaoxqjGqMaoxqjWgwV/lS+xfq7pBVjqNiMahbsoFfz5+st1uIlGRQwxvVos3UpsWjFdSmx2MAOEjhABgX0av70vsUSvqQVYwDZbGAH471FD4gBZMSJGANITCTE2r4+oiVjqFj/IIaKzQiL5ouhYnOADAqo4AQtGQv/kg3sIIEDZFDAqGbBCVoxhorNBnaQwAEyKCCqNVRrqNZRraNaDBX+XL7FKsHkABkUUMEJWjGGik2UIJSI8cEf9LdYMZgUUMEo0YNRws+dWDmYbGAHCRwggwIqOEFUY1RjVGNUY1SL8cEf5bdYY5gUUMEJWnF9D3KxgR1ECUEJQQlBCUEJQQlFCUUJRYkYFDajGgcZFFDBCVoxBoXNBnaQQFSbqDZRbaLaRLWJaoZqMWpwfDk0Ro1NAgcYuRqcoCVjDWKygR0kcIDxLmZQQAUnaMUYHzYb2EECUaKhREOJhhINJTpKdJToKNFRYg0Ki1HNggIqOEErrkFhsYEdJNBzfZHETQUnaMUYCTYb2EEC/V34MocW6xaTAio4QSvGSLDZwA6iBKMEowSjBKMEo4SghKCEoMT6MvRiVOtBBgVUcIJWjJFgs4EdJBDVFNUU1RTVFNUU1SaqTVSLkcDXg7RY5pgcIIMCKjhBK8ZI4CtJWix8THaQwKjGQQYFVHCCloy1kMkGdpDAATIY1SSoYFTToBVjfNhsYAcJHCCDAiqIag3VYqjwdSYtFkgmo5oFCRwggwIqOEErxlCx2UBUI1SLS4lYixKLKZMCerVYlhLrKZNWjAFk06vF8pFYU5kkMKpRkEEBFYwrsZVrxRhAYn1JLK5MdpDAATIY7yJOmBg1FmPU2IzcOHdi1NgkcIAMCqjgBK0Yo8YmqimqKaopqimqxagRSzdiqWVyglaMUWOzgR0kcIAMotpEtYlqE9UM1WLUiDUjsfIySeAAGRRQwQlaMlZgJhvYQQIHyGBUs6CCE7RijBqbDewggQNkENUaqsWoEQtQYlHmZowamw3sIIEDZFBABVGtoxqhGqEaoRqhGqEaoRqhGqEaoRqh2kC1GDViRU2s1UwSOEAGBZygFWOo2EQJRglGCUYJRom47Ij1O7FeMzlBK8YAstnADhI4QJQQlBCUEJRQlFCUUJRQlFCUiFFjM6pRUMEJWjFGjc0GdpDAATKIahPVJqpNVDNUM1QzVItRI9YmxUrOJIMCRi7Hb225wAZ2kMABMihgvAsJTtCKMT5sNrCDBA6QQZRoKLEGBY1fOnOBDewggQNkUEAFJ4hqhGqEaoRqhGprUJhBBgVUMKpZ0IprUFhsYAcJHKBX81VTPVZrJhWcRR8U4lj6kLDQE5QYCU5IQhMzYRsxAPh6rB7LMeO4xS+3CFBiJDghCU3MhG3Er7v444/v3uXvivv+10/v3/uvivvsl8f9/fd3v/zw6f1Pv77720+/ffz43bv/+eHjb/GP/vvLDz/F9tcfPt1/ezfE+5/+dW/vwH9/+Pje9cd3ePX1+qXxdZV48T0BXC/nr3+9Txas10s7eb0/Ktuv769eT/9/r48b4Xh9f73/T6+f9Xrjg9dTz/ajcbL/xFn/ftD86vXzof3UV/OsBrxnSE4SLl+0tBLuQfLNCXKUQFcl0HxrwqCjBEYCn+2D36/shElvTjjah/hq/kq4/eYEPkro9S7a2dGMebOVcN+xH+1DdWxfGHq0Dw370MdRQq/B7X4MeLYPhH04OhbxMbsTbL4xga6js5p8Yc9OOHsXnyfQdTLOWp6S4/WR8OUOrwLuZ59tJ9wPPO0kwpfI5LsYr9vhqyNeN8RzxKhPjMH97RF6FiGI0MO9mNVBh+lbI/g62wvuNVxyp7OIJogYb484OzuZ0BaH54VoDVf3k7GzvbA6L+TwiAhhL15//DxHjDqo98PSs4iu2IuzI6LtwrXdWXP+6fKwvz1CD8beUY05Xn8C8cNNhrQave8n/0cRY155do/5+l18dUTvZxEkFTHG2yPsLIIRIYd7UZ+GN+3NEXa2F9ZGnVmvL1WfI66JCHlzRG8nEUwzj8g9Ch+2BdcVzj21eRZhdUTMjvoIXy37+v15ep1F6FURenREuNcNKfd2dkR6DVrc+awt+mcH9ToaLxjTO/cHPJ2dWnWtdpPPImgiQt4cwWdtMXod1NHHWURdPfPDBfhXR9DZqTUGV4QcRigiDnvqZxF8nZ1aXHfIfJ8YZxFcd1UsZ2/kTzdm9PYIO7jE4fpE5aNpSK5rLH49DerPPF7OY169JjLvZwAnEax1fcNPU4lfG9H7WURd37C+vkT6+gg7i8ABVTncC5xUOu3NEXa2F7MukW7yWURd39wR8uaI15dITxHSavi/Oc4ias5Bmp6dnbOusnjKWTczqVPLzvZCrvoEkfu52VlEXWXdnGfNWR+F9xHhN0e8ns56bs5ZH8hmZ3sR3/bO28uzI/KnO1R6e8Q8+RCRWYf0ZVu26+Fe/57nznPznm62owxfjJLzBfb6mdgXMuqgtoeD+rUZvurgLGNqzYlNO30vmMWxNt+e8XqS8fnYXvWo0tcZnGbgKqPPt2e8vlJ5OM8xOSfj6PWX1Otfvwf/nu/L98D1SXLfHOpZBp7t9P76M/EvZMhZRqurpd5eX3D9hQw7zMCj/Hv2+LA9Ph+/xjfIOLkZEK7LjNdPHuP3ub6ciel10z7662uEx4w+ajfud6SHGTbrPL/k7RmvJ2OeM7im9O/D+i0y+DCjHvbccddhe9SFbH94FvkXju3h+cF1BXjztE0/Hwf7N8g4eb4gdeGkD59r4+kJhdTn/NDrMOOymlVvrx+1PGfE3+6M1xf2fyFDDjNqcmg0u44yumAclYdryecMrWs4mfz2jNP3onWHcPPwvWgdl66v1xc9ZxhXxj3ff5hRl093xmF7mNaYbkanGdiP15MbX5tBT9f4Txl01RJEumgcZtS5ThefZohVhp6NQdTq8Qu1Pg8zaoqDTscPwnOLO0PfniF0mFETaNTscD/i1yitjN7pG2TYYQba4x5QDzOszo9up++lHmvdGePNGXTabwn9lk77LXG1B8n1DTIO+8uo+3t6eLb1hYz6fLmf8x32/aFYzmyH5ynX5CQ9PNL5QgbOj4dVQM8ZUvMMJOOwTWXWe5HT8UPq+vaOO9wPrRW1Nw/PMa2ndXR6nfynDDocP5S1Mk7PU63Hhjft7Rmn46nO6nN62l+m4CsAeniuz1FtOg/bY1xSqz8engg8Z3QsyOl0HWZ8NvdxOJ5+5fzJQ4LWZIE+jGH+Kw9f3pVqzT/Lw5O3x4xBNXcyxsP8y2PGGFdlPMx3fnUG02EG7inH/BYZephR4/F4WHn8nMFX7Qe/Xub0hWOL+3Tiw2NLWu+FZv8GGYdtyngv/DD+PGcoMozfnCFXO8uQeiY5hA7bVOpafYgcvpc/zUm1b5BxMrem1aDz9beJ4pepvUzgmn/R+2n1UYYQ1Vj6sIjtCxnVFvJwnn99xuvngc8Zoz4j7wdZ3yJDDjNqkeQd1w4zBvbjdb9/zoivwu/n3nZ6bOs52N1l2zfIOG3TiTa1w/Zg7AcTvz1jHLYH132t8Omx5ZonvKeA6SxD6j5fhE4z6lpfRA77vtRckuhF3yDjsE1xLyg6rsOMuge7Z8cP38vn17fH7+WrrpEfPp9mfe9pPhzX8fC8d1KtTZtP/f4pQ/AVALE2DjPqGfrNeZRxXyfUZ+3DGo+n9qzPe2uvj+l4+rzH0klVOW1PnOP20OefMxjt+fr55hfas5776MM327+QIb0y9PoGGeMwg/FeHsbz54yaP9Z2nfU3bXUvqe31M6wvZCj2Yx72lfh/euzHxtfhse0dj57H4bGNX5a3M+ZpRn1rUuk6PNep5kvvyY/D40KCDD3NwDk2rsPzFGss9OFbGn8h4/BcH+hzQ+kbZJy2h9V74cZvz+iHbcpU5zqzvj1DDtv0s3tSNntzxtN97dNn5bf4tO11djx84+ILGfX06eY8zMCorsyHGfW0Red1nWXMXqP6HIf7MWeNptMO28PQa03Oju28KDPmNeQwo2Ys7ov0cZbRWu1H63qYUV8AnO3wuEx8f2M2PWzTjhuGhycUX8ioJ5yzH57rs+O4PDyJf874ujuXx/UzWLby59f/4/7phx8/fPr+s99n9vsfnvTpww///Ph+//jv33768bO//fV/f8m/+eenDx8/fvjP9798+vnH9//67dN7T/K/e3ft//y9+/+tuDcb//juXfefrznvnxvdP4/4+3uW6z5edv/M8bPxd70P/1n8Z/89d536vH/W+Jmv+++n3D9P/5nusaCT6f2zxc/305T72F33zy124PIduB92+R+09Qf3K67Z/vGHN8H/AQ==", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 8e531d3e5db..915ac59b8e8 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2073 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2079 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2079 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2050 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2085 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2088 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 434 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 434 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 427 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 433 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 434 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 439 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 445 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 451 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 457 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 463 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 472 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 478 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 496 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 502 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 509 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 517 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 523 }, Call { location: 2170 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 539 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 547 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2088 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 563 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 567 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 573 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 586 }, Jump { location: 577 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 619 }, Jump { location: 597 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 600 }, Jump { location: 609 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 609 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 612 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 618 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 628 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 631 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 637 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 645 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 664 }, Jump { location: 653 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 663 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 683 }, JumpIf { condition: Relative(29), location: 666 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 674 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 683 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 687 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 693 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 722 }, Jump { location: 714 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 721 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 738 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 729 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2173 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 738 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 745 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 753 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 785 }, Jump { location: 761 }, JumpIf { condition: Relative(29), location: 763 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 771 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 796 }, JumpIf { condition: Relative(29), location: 787 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 795 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 796 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 800 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 806 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 814 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 854 }, Jump { location: 826 }, JumpIf { condition: Relative(29), location: 828 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 836 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 842 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1196 }, JumpIf { condition: Relative(29), location: 856 }, Call { location: 2085 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 864 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 877 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 889 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 902 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 908 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 911 }, Call { location: 2085 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 919 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 925 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 931 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 951 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 964 }, Call { location: 2085 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 971 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 977 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 983 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 989 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 995 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1008 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1014 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1020 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1026 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1032 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1038 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1053 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1059 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1065 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1071 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2287 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1083 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1089 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1095 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1099 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1102 }, Call { location: 2085 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2329 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1115 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1121 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1124 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1130 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1136 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1142 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1148 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1154 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1157 }, Call { location: 2085 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2398 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1175 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1183 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1189 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1195 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1196 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1204 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1210 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1216 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1224 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1275 }, Jump { location: 1235 }, JumpIf { condition: Relative(22), location: 1237 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1245 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1263 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1295 }, JumpIf { condition: Relative(22), location: 1277 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1285 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1295 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1303 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1309 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1315 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1323 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1329 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1346 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1352 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1358 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1366 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1417 }, Jump { location: 1377 }, JumpIf { condition: Relative(27), location: 1379 }, Call { location: 2085 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1387 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1405 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1437 }, JumpIf { condition: Relative(27), location: 1419 }, Call { location: 2085 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1427 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1437 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1445 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1451 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1457 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1465 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1469 }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1477 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1497 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1512 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1518 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1524 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1532 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1538 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1555 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1561 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1567 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1575 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1632 }, Jump { location: 1590 }, JumpIf { condition: Relative(22), location: 1592 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1605 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1620 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1664 }, JumpIf { condition: Relative(22), location: 1634 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1652 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1664 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1672 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1689 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1695 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1697 }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1703 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1723 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1754 }, Jump { location: 1736 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1742 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1754 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1762 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1780 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1790 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1798 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1804 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1812 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1818 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1826 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1832 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1841 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1848 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1948 }, Jump { location: 1858 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1861 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1874 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1889 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1904 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1910 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1916 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1931 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1939 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1945 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1966 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1954 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1966 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1974 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1991 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1997 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1999 }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2005 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2032 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2038 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2049 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2058 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2078 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2092 }, Jump { location: 2094 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2113 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2111 }, 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: 2104 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2113 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2125 }, Jump { location: 2142 }, JumpIf { condition: Direct(32781), location: 2127 }, Jump { location: 2131 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2141 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2141 }, Jump { location: 2154 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2154 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2168 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2168 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2161 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2177 }, Jump { location: 2179 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2194 }, 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: 2191 }, 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: 2184 }, 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: 2194 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2206 }, Jump { location: 2223 }, JumpIf { condition: Direct(32781), location: 2208 }, Jump { location: 2212 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2222 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2222 }, Jump { location: 2235 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2235 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2248 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2241 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2259 }, Jump { location: 2263 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2285 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2284 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2277 }, Jump { location: 2285 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2297 }, Jump { location: 2305 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2328 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2327 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2320 }, Jump { location: 2328 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2340 }, Jump { location: 2357 }, JumpIf { condition: Direct(32782), location: 2342 }, Jump { location: 2346 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2356 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2356 }, Jump { location: 2369 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2369 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2383 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2383 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2376 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2397 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2390 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2407 }, Jump { location: 2413 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2435 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2434 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2427 }, Jump { location: 2435 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2450 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2443 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2062 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2068 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2068 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2039 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2074 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2074 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2077 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2077 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2074 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2074 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2077 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2074 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2074 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 423 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 423 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Jump { location: 423 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 428 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 434 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 440 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 446 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 452 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 461 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 467 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 485 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 491 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 498 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 506 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 512 }, Call { location: 2159 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 517 }, Call { location: 2074 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 525 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2074 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2077 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 552 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 556 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 562 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 575 }, Jump { location: 566 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 617 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 608 }, Jump { location: 586 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 589 }, Jump { location: 598 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 598 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 601 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 607 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 617 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 617 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 620 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 626 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 634 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 653 }, Jump { location: 642 }, JumpIf { condition: Relative(29), location: 644 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 652 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 672 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 663 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 672 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 676 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 682 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 711 }, Jump { location: 703 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 710 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 727 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 718 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2162 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 727 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 734 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 742 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 774 }, Jump { location: 750 }, JumpIf { condition: Relative(29), location: 752 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 760 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 785 }, JumpIf { condition: Relative(29), location: 776 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 784 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 785 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 789 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 795 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 803 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 843 }, Jump { location: 815 }, JumpIf { condition: Relative(29), location: 817 }, Call { location: 2074 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 825 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 831 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1185 }, JumpIf { condition: Relative(29), location: 845 }, Call { location: 2074 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 853 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 866 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 878 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 891 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 897 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 900 }, Call { location: 2074 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 908 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 914 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 920 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2077 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 940 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2184 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 953 }, Call { location: 2074 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 960 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 966 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 972 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 978 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 984 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2184 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 997 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1003 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1009 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1015 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1021 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1027 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1042 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1048 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1054 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1060 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2276 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1072 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1078 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1084 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1088 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1091 }, Call { location: 2074 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2318 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1104 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1110 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1113 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1119 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1125 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1131 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1137 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1143 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1146 }, Call { location: 2074 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2387 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1164 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1172 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1178 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1184 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1185 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1193 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1199 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1205 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1213 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1264 }, Jump { location: 1224 }, JumpIf { condition: Relative(22), location: 1226 }, Call { location: 2074 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1234 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1252 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1284 }, JumpIf { condition: Relative(22), location: 1266 }, Call { location: 2074 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1274 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1284 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1292 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1298 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1304 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1312 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1318 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1335 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1341 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1347 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1355 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1406 }, Jump { location: 1366 }, JumpIf { condition: Relative(27), location: 1368 }, Call { location: 2074 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1376 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1394 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1426 }, JumpIf { condition: Relative(27), location: 1408 }, Call { location: 2074 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1416 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1426 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1434 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1440 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1446 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1454 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1458 }, Jump { location: 1478 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1466 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1478 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1486 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1501 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1507 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1513 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1521 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1527 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1544 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1550 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1556 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1564 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1621 }, Jump { location: 1579 }, JumpIf { condition: Relative(22), location: 1581 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1594 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1609 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1653 }, JumpIf { condition: Relative(22), location: 1623 }, Call { location: 2074 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1641 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1653 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1661 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1678 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1684 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1686 }, Jump { location: 1704 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1692 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1704 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1712 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1743 }, Jump { location: 1725 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1731 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1743 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1751 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1769 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1776 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1779 }, Call { location: 2074 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1793 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1801 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1807 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1815 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1821 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1830 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1837 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1937 }, Jump { location: 1847 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1850 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1863 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1878 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1893 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1899 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1905 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1920 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1928 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1934 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1955 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1943 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1955 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1963 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1980 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1986 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1988 }, Jump { location: 2006 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 1994 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2006 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2021 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2027 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2038 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2047 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2067 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2081 }, Jump { location: 2083 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2102 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2100 }, 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: 2093 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2102 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2114 }, Jump { location: 2131 }, JumpIf { condition: Direct(32781), location: 2116 }, Jump { location: 2120 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2130 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2130 }, Jump { location: 2143 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2143 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2157 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2157 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2150 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2166 }, Jump { location: 2168 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2183 }, 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: 2180 }, 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: 2173 }, 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: 2183 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2195 }, Jump { location: 2212 }, JumpIf { condition: Direct(32781), location: 2197 }, Jump { location: 2201 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2211 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2211 }, Jump { location: 2224 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2224 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2237 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2230 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2248 }, Jump { location: 2252 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2274 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2273 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2266 }, Jump { location: 2274 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2286 }, Jump { location: 2294 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2317 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2316 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2309 }, Jump { location: 2317 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2329 }, Jump { location: 2346 }, JumpIf { condition: Direct(32782), location: 2331 }, Jump { location: 2335 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2345 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2345 }, Jump { location: 2358 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2358 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2372 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2372 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2365 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2386 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2379 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2396 }, Jump { location: 2402 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2424 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2423 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2416 }, Jump { location: 2424 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2439 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2432 }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", From cfa132a7f812bd11e2fe58ce790ae28d5372975b Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 16:06:11 -0300 Subject: [PATCH 10/41] Add all successors transitively right away --- .../opt/remove_unreachable_instructions.rs | 66 ++++++++++++++----- 1 file changed, 50 insertions(+), 16 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 0cf63cc90f1..51453201780 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -13,8 +13,8 @@ use noirc_errors::call_stack::CallStackId; use crate::ssa::{ ir::{ - basic_block::BasicBlockId, function::Function, instruction::Instruction, types::Type, - value::ValueId, + basic_block::BasicBlockId, dfg::DataFlowGraph, function::Function, + instruction::Instruction, types::Type, value::ValueId, }, ssa_gen::Ssa, }; @@ -51,15 +51,6 @@ impl Function { if current_block_id != Some(block_id) { current_block_id = Some(block_id); current_block_instructions_are_unreachable = unreachable_blocks.contains(&block_id); - - if current_block_instructions_are_unreachable { - for successor in context.dfg[block_id].successors() { - if !seen_blocks.contains(&successor) { - unreachable_blocks.insert(successor); - } - } - } - seen_blocks.insert(block_id); } @@ -95,11 +86,7 @@ impl Function { unreachable_blocks.insert(block_id); current_block_instructions_are_unreachable = true; - for successor in context.dfg[block_id].successors() { - if !seen_blocks.contains(&successor) { - unreachable_blocks.insert(successor); - } - } + add_successors(&seen_blocks, &mut unreachable_blocks, context.dfg, block_id); } }); @@ -114,6 +101,23 @@ impl Function { } } +/// Recursively adds a block's successors to `unreachable_blocks` unless they were already seen. +fn add_successors( + seen_blocks: &HashSet, + unreachable_blocks: &mut HashSet, + dfg: &DataFlowGraph, + block_id: BasicBlockId, +) { + let mut blocks_to_process = vec![block_id]; + while let Some(block_id) = blocks_to_process.pop() { + for successor in dfg[block_id].successors() { + if !seen_blocks.contains(&successor) && unreachable_blocks.insert(successor) { + blocks_to_process.push(successor); + } + } + } +} + fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> ValueId { match typ { Type::Numeric(numeric_type) => { @@ -291,6 +295,36 @@ mod test { "#); } + #[test] + fn removes_unreachable_instructions_following_block_with_no_instructions() { + let src = r#" + acir(inline) predicate_pure fn main f0 { + b0(): + constrain u1 0 == u1 1, "Index out of bounds" + jmp b1() + b1(): + jmp b2() + b2(): + v2 = add Field 1, Field 2 + return v2 + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + constrain u1 0 == u1 1, "Index out of bounds" + jmp b1() + b1(): + jmp b2() + b2(): + return Field 0 + } + "#); + } + #[test] fn does_not_zeroes_terminator_of_previously_seen_blocks() { let src = r#" From 50ab93a709e2e5d7d01b9a17be6bde5b52b0b1d2 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 16:17:20 -0300 Subject: [PATCH 11/41] One more snapshot --- ...rce_brillig_true_inliner_9223372036854775807.snap | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 12a59342163..f5bd611e4d9 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -66,10 +66,6 @@ expression: artifact "error_kind": "string", "string": "attempt to add with overflow" }, - "12049594436772143978": { - "error_kind": "string", - "string": "array ref-count underflow detected" - }, "14225679739041873922": { "error_kind": "string", "string": "Index out of bounds" @@ -88,14 +84,10 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 525 }, 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(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 121 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 115 }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(13), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Relative(2) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(15), location: 451 }, Jump { location: 138 }, Load { destination: Relative(14), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(9) }, Load { destination: Relative(8), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 145 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Load { destination: Relative(8), source_pointer: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(7) }, JumpIf { condition: Relative(8), location: 153 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(9), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(9), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(10) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(8) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(11) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Mov { destination: Relative(14), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, Mov { destination: Relative(5), source: Relative(10) }, Jump { location: 172 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(9), location: 404 }, Jump { location: 175 }, Load { destination: Relative(5), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 182 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(9), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 226 }, Jump { location: 186 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U8, lhs: Relative(14), rhs: Relative(9) }, JumpIf { condition: Relative(15), location: 191 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(14), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 531 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Store { destination_pointer: Relative(16), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Load { destination: Relative(14), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Div, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(18), op: Div, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, BinaryIntOp { destination: Relative(17), op: Sub, bit_size: U32, lhs: Relative(14), rhs: Relative(19) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, JumpIf { condition: Relative(18), location: 209 }, Call { location: 553 }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 531 }, Mov { destination: Relative(16), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Store { destination_pointer: Relative(17), source: Relative(14) }, Store { destination_pointer: Relative(6), source: Relative(16) }, Cast { destination: Relative(14), source: Relative(1), bit_size: Field }, Const { destination: Relative(1), bit_size: Field, value: 10 }, BinaryFieldOp { destination: Relative(15), op: Div, lhs: Relative(1), rhs: Relative(14) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(14), op: Equals, lhs: Relative(15), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(14), rhs: Relative(7) }, JumpIf { condition: Relative(1), location: 225 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Jump { location: 235 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 531 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(10) }, Store { destination_pointer: Relative(14), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 235 }, Load { destination: Relative(1), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(7), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 242 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(9) }, JumpIf { condition: Relative(5), location: 250 }, Jump { location: 247 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 262 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(9), size: Relative(14) }, output: HeapArray { pointer: Relative(15), size: 32 } }), BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 262 }, Load { destination: Relative(7), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(7), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 269 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 276 }, Call { location: 556 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(4) }, 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: Relative(1) }, Mov { destination: Relative(3), source: Relative(10) }, Jump { location: 283 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 357 }, Jump { location: 286 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 294 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, JumpIf { condition: Relative(5), location: 302 }, Jump { location: 299 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 317 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 531 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(10) }, Store { destination_pointer: Relative(9), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(7) }, JumpIf { condition: Relative(5), location: 315 }, Jump { location: 312 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 317 }, Store { destination_pointer: Relative(3), source: Relative(8) }, Jump { location: 317 }, Load { destination: Relative(1), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 323 }, Jump { location: 325 }, Store { destination_pointer: Relative(3), source: Relative(11) }, Jump { location: 325 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(3), location: 330 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 335 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 344 }, Jump { location: 338 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 343 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 351 }, Jump { location: 354 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 354 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 335 }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 359 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(7), location: 365 }, Jump { location: 362 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 283 }, Load { destination: Relative(7), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 372 }, Call { location: 559 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(14) }, JumpIf { condition: Relative(7), location: 378 }, Jump { location: 401 }, Load { destination: Relative(7), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 531 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Store { destination_pointer: Relative(17), source: Relative(14) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 531 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Store { destination_pointer: Relative(16), source: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(7) }, Jump { location: 401 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(7) }, Jump { location: 359 }, Mov { destination: Relative(9), source: Relative(2) }, Jump { location: 406 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(5) }, JumpIf { condition: Relative(15), location: 412 }, Jump { location: 409 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(9) }, Jump { location: 172 }, Load { destination: Relative(15), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(16), source_pointer: Relative(18) }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(12) }, JumpIf { condition: Relative(17), location: 419 }, Call { location: 559 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(9) }, Load { destination: Relative(17), source_pointer: Relative(19) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(17) }, JumpIf { condition: Relative(15), location: 425 }, Jump { location: 448 }, Load { destination: Relative(15), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(19) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 531 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(9) }, Store { destination_pointer: Relative(20), source: Relative(17) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 531 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Store { destination_pointer: Relative(14), source: Relative(15) }, Jump { location: 448 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(10) }, Mov { destination: Relative(9), source: Relative(15) }, Jump { location: 406 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 454 }, Jump { location: 460 }, Mov { destination: Relative(15), source: Relative(2) }, Jump { location: 456 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 463 }, Jump { location: 459 }, Jump { location: 460 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(15) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 467 }, Call { location: 553 }, Load { destination: Relative(18), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 472 }, Call { location: 562 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(19), rhs: Relative(12) }, JumpIf { condition: Relative(20), location: 475 }, Call { location: 559 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(19) }, Load { destination: Relative(20), source_pointer: Relative(22) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(9) }, JumpIf { condition: Relative(19), location: 482 }, Call { location: 559 }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 531 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(20) }, Store { destination_pointer: Relative(8), source: Relative(19) }, Mov { destination: Relative(16), source: Relative(2) }, Jump { location: 492 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, JumpIf { condition: Relative(17), location: 512 }, Jump { location: 495 }, Load { destination: Relative(16), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, JumpIf { condition: Relative(17), location: 499 }, Jump { location: 509 }, Load { destination: Relative(16), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 531 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Store { destination_pointer: Relative(6), source: Relative(18) }, Jump { location: 509 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Mov { destination: Relative(15), source: Relative(16) }, Jump { location: 456 }, Load { destination: Relative(17), source_pointer: Relative(7) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(16) }, Load { destination: Relative(19), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(17), rhs: Relative(18) }, JumpIf { condition: Relative(20), location: 521 }, Call { location: 553 }, Store { destination_pointer: Relative(7), source: Relative(18) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Mov { destination: Relative(16), source: Relative(17) }, Jump { location: 492 }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 530 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, 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: 535 }, Jump { location: 537 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 552 }, 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: 549 }, 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: 542 }, 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: 552 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 361 }, 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(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 121 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 115 }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(13), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Relative(2) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 287 }, Jump { location: 138 }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(4), source_pointer: Relative(7) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(5), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(9), source: Relative(8) }, Store { destination_pointer: Relative(9), source: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(5) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(12) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Mov { destination: Relative(3), source: Relative(10) }, Jump { location: 172 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(7), location: 240 }, Jump { location: 175 }, Load { destination: Relative(3), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 182 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 192 }, Jump { location: 185 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 191 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Jump { location: 201 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 367 }, Mov { destination: Relative(3), source: Direct(32773) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 201 }, JumpIf { condition: Relative(4), location: 204 }, Jump { location: 203 }, Jump { location: 205 }, Jump { location: 205 }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 207 }, JumpIf { condition: Relative(4), location: 229 }, Jump { location: 209 }, JumpIf { condition: Relative(4), location: 212 }, Jump { location: 211 }, Jump { location: 216 }, JumpIf { condition: Relative(4), location: 215 }, Jump { location: 214 }, Jump { location: 216 }, Jump { location: 216 }, JumpIf { condition: Relative(4), location: 218 }, Jump { location: 219 }, Jump { location: 219 }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 221 }, JumpIf { condition: Relative(4), location: 224 }, Jump { location: 223 }, Return, JumpIf { condition: Relative(4), location: 226 }, Jump { location: 227 }, Jump { location: 227 }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 221 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 231 }, JumpIf { condition: Relative(4), location: 235 }, Jump { location: 233 }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 207 }, JumpIf { condition: Relative(4), location: 237 }, Jump { location: 238 }, Jump { location: 238 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 231 }, Mov { destination: Relative(7), source: Relative(2) }, Jump { location: 242 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 248 }, Jump { location: 245 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Mov { destination: Relative(3), source: Relative(7) }, Jump { location: 172 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 255 }, Call { location: 389 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(7) }, Load { destination: Relative(14), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(14) }, JumpIf { condition: Relative(8), location: 261 }, Jump { location: 284 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 367 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(7) }, Store { destination_pointer: Relative(17), source: Relative(14) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 367 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Store { destination_pointer: Relative(16), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 284 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(10) }, Mov { destination: Relative(7), source: Relative(8) }, Jump { location: 242 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 290 }, Jump { location: 296 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 292 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 299 }, Jump { location: 295 }, Jump { location: 296 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(3) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 303 }, Call { location: 392 }, Load { destination: Relative(16), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(17), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Relative(3) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(18), location: 308 }, Call { location: 395 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 311 }, Call { location: 389 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(17) }, Load { destination: Relative(18), source_pointer: Relative(20) }, Load { destination: Relative(16), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 318 }, Call { location: 389 }, Mov { destination: Direct(32771), source: Relative(16) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 367 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(15) }, Store { destination_pointer: Relative(20), source: Relative(18) }, Store { destination_pointer: Relative(8), source: Relative(17) }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 328 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(15), location: 348 }, Jump { location: 331 }, Load { destination: Relative(4), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(14) }, JumpIf { condition: Relative(15), location: 335 }, Jump { location: 345 }, Load { destination: Relative(4), source_pointer: Relative(7) }, Load { destination: Relative(15), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 367 }, Mov { destination: Relative(16), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Store { destination_pointer: Relative(17), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(16) }, Jump { location: 345 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 292 }, Load { destination: Relative(15), source_pointer: Relative(7) }, Load { destination: Relative(16), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(19) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(15), rhs: Relative(16) }, JumpIf { condition: Relative(18), location: 357 }, Call { location: 392 }, Store { destination_pointer: Relative(7), source: Relative(16) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Mov { destination: Relative(4), source: Relative(15) }, Jump { location: 328 }, 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: 366 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, 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: 371 }, Jump { location: 373 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 388 }, 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: 385 }, 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: 378 }, 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: 388 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "pZfBbtswEET/xWcfuCSXS+ZXiiBwEqUwYDiBYxcoAv97OdKOkh5cFMzF82R5RuSSWksfm+fp8fLzYX98eX3f3P342Dye9ofD/ufD4fVpd96/Hvu3H5uADwllcyfbruZaXduiElzFNbom1+yqrp4nnieeJ54XPS96XvS86HnR86LnRc9L/ThCe16C9rzcNQfXnqfQ6Jpcs6u69rwCNdfq2hbV4Cqu0bXnGTS7qmtxNdfq2hYtwVVco6vnFc8rnlc8r/S8Bq2ubVFDvQIABUJlDBVCacwIqDmKZM2hBoIQkIPCVeRghrUQjFAJzaEFAuwYZ8O6VUAmKKEQjFAJbYGI5ZIG8OlELMjyTf9N7DONWJIFhBAJiZAJ2CfIwcIsYISeHHt9ItZiAeQkQCJkAnIyoBCMgBwFNAcLBCFEQiJkAmc6L9wMRqiE5jAv3AxCiIRMwMD6okQsSjRAmW+SiDLHXuYUAkEIkZAIGGADKKEQjFAJzQH9YYGenAIgEhIhE5RQCEbAfS2A5oBOsYAQIiERMkEJyOlrmxJcCQBXBiihEGyuU/KmktBUoGgqs4prdE2u6sqLYa/OgL2aFCCESEg+IOzVBZRQCEZAcrpetxv27IfzaZrQsr808d7a33an6Xje3B0vh8N282t3uMw/en/bHWc97079bK/wdHzu2gNf9ocJdN1+usNtaw7m5iy62vX//VrpL2HAb4mDt5QH/DXQX0P9nl/SiD+yfjWN1K9hp87+NuZHM3W/3fLX2/7eytzf29OAX9XtWgbc/c/I7dJkZPbK1Wuav+lvI35b/VYG/BJyYgGC3qy/6DcX8J9DWHeQhBjGEuKaICPbwNp6Dw+4W/0c/8geDLr62/cuP2KXVOjPI7Pvj5b0l6Hrrw28P7wOrL4GNjCVkVtQs9Cfh65fWD+1kRaixhaktQz51w5YbWj86/xtZP5FOP4iI/d/yaxf0SF/4/UtjMy/qNy4/n0/2j3tT3+9116RdNrvHg+TH75cjk9fzp5/v/EM34vfTq9P0/PlNCHp8+W4f/xIxbap1vv+TNaPWthKCPd4P57PyTaVgkPBYdNtanZ/xcj+AA==", "file_map": { - "19": { - "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", - "path": "std/hash/mod.nr" - }, "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", "path": "" From da3d2c22a0286390dd06c452ad2150a6de37db3f Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 17:35:45 -0300 Subject: [PATCH 12/41] DominatorTree to the rescue! --- .../opt/remove_unreachable_instructions.rs | 109 ++++++++++++++---- 1 file changed, 86 insertions(+), 23 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 51453201780..d8a232d568d 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -3,8 +3,8 @@ //! any subsequent instructions in that block will never be executed. This pass //! then removes those subsequent instructions and replaces the block's terminator //! values with zeroed values of the appropriate type. If the block has successors -//! those successors will also be unreachable if they come afterwards in a pre-order -//! traversal. +//! those successors will also be considered unreachable if they are dominated +//! by that block. use std::sync::Arc; use acvm::{AcirField, FieldElement}; @@ -13,7 +13,7 @@ use noirc_errors::call_stack::CallStackId; use crate::ssa::{ ir::{ - basic_block::BasicBlockId, dfg::DataFlowGraph, function::Function, + basic_block::BasicBlockId, dfg::DataFlowGraph, dom::DominatorTree, function::Function, instruction::Instruction, types::Type, value::ValueId, }, ssa_gen::Ssa, @@ -30,17 +30,14 @@ impl Ssa { impl Function { fn remove_unreachable_instructions(&mut self) { + let mut dom = DominatorTree::with_function(self); + // The current block we are currently processing let mut current_block_id = None; // Whether the current block instructions were determined to be unreachable let mut current_block_instructions_are_unreachable = false; - // This is the set of all blocks we've seen so far. We need to keep this because when - // we determine that a block is unreachable, all of its successors are also unreachable - // but only if we didn't see them before. - let mut seen_blocks = HashSet::default(); - // This is the final set of blocks that we concluded have some unreachable instructions. // At the end we'll zero out their terminators. let mut unreachable_blocks = HashSet::default(); @@ -51,7 +48,6 @@ impl Function { if current_block_id != Some(block_id) { current_block_id = Some(block_id); current_block_instructions_are_unreachable = unreachable_blocks.contains(&block_id); - seen_blocks.insert(block_id); } if current_block_instructions_are_unreachable { @@ -86,7 +82,7 @@ impl Function { unreachable_blocks.insert(block_id); current_block_instructions_are_unreachable = true; - add_successors(&seen_blocks, &mut unreachable_blocks, context.dfg, block_id); + add_successors(block_id, context.dfg, &mut dom, &mut unreachable_blocks); } }); @@ -101,21 +97,32 @@ impl Function { } } -/// Recursively adds a block's successors to `unreachable_blocks` unless they were already seen. +/// Adds all of a block's successors to the `unreachable_blocks` set if they are dominated by that block. fn add_successors( - seen_blocks: &HashSet, - unreachable_blocks: &mut HashSet, - dfg: &DataFlowGraph, block_id: BasicBlockId, + dfg: &DataFlowGraph, + dom: &mut DominatorTree, + unreachable_blocks: &mut HashSet, ) { + // First compute the set of all successors + let mut all_successors = HashSet::default(); + all_successors.insert(block_id); + let mut blocks_to_process = vec![block_id]; while let Some(block_id) = blocks_to_process.pop() { for successor in dfg[block_id].successors() { - if !seen_blocks.contains(&successor) && unreachable_blocks.insert(successor) { + if all_successors.insert(successor) { blocks_to_process.push(successor); } } } + + // Now add them to `unreachable_blocks` if they are dominated by the block + for successor in all_successors { + if dom.dominates(block_id, successor) { + unreachable_blocks.insert(successor); + } + } } fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> ValueId { @@ -162,7 +169,10 @@ fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> #[cfg(test)] mod test { - use crate::{assert_ssa_snapshot, ssa::ssa_gen::Ssa}; + use crate::{ + assert_ssa_snapshot, + ssa::{opt::assert_normalized_ssa_equals, ssa_gen::Ssa}, + }; #[test] fn removes_unreachable_instructions_in_block() { @@ -346,22 +356,75 @@ mod test { "#; let ssa = Ssa::from_str(src).unwrap(); let ssa = ssa.remove_unreachable_instructions(); + assert_normalized_ssa_equals(ssa, src); + } - assert_ssa_snapshot!(ssa, @r#" + #[test] + fn does_not_consider_block_as_unreachable_if_it_has_other_predecessors_1() { + let src = r#" acir(inline) predicate_pure fn main f0 { b0(): jmp b1() b1(): - v2 = add Field 1, Field 2 - jmp b2(v2) + jmpif u1 0 then: b2, else: b3 b2(): - jmpif u1 0 then: b3, else: b4 + constrain u1 0 == u1 1, "Index out of bounds" + jmp b3() b3(): + v1 = add Field 1, Field 2 + return v1 + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(); + assert_normalized_ssa_equals(ssa, src); + } + + #[test] + fn does_not_consider_block_as_unreachable_if_it_has_other_predecessors_2() { + let src = r#" + acir(inline) predicate_pure fn main f0 { + b0(): + jmp b1() + b1(): + jmpif u1 0 then: b2, else: b3 + b2(): constrain u1 0 == u1 1, "Index out of bounds" - jmpif u1 0 then: b4, else: b1 + jmp b4() + b3(): + jmp b4() b4(): - return Field 0 + v1 = add Field 1, Field 2 + return v1 } - "#); + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(); + assert_normalized_ssa_equals(ssa, src); + } + + #[test] + fn does_not_consider_block_as_unreachable_if_it_has_other_predecessors_3() { + let src = r#" + acir(inline) predicate_pure fn main f0 { + b0(): + jmp b1() + b1(): + jmpif u1 0 then: b2, else: b3 + b2(): + constrain u1 0 == u1 1, "Index out of bounds" + jmp b4() + b3(): + jmp b4() + b4(): + jmp b5() + b5(): + v1 = add Field 1, Field 2 + return v1 + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(); + assert_normalized_ssa_equals(ssa, src); } } From f1eeaf20d20c25b68152329eefc020ac30593b20 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Thu, 19 Jun 2025 17:35:54 -0300 Subject: [PATCH 13/41] Snapshots --- ...rillig_true_inliner_-9223372036854775808.snap | 12 ++++++++++-- ...ute__tests__force_brillig_true_inliner_0.snap | 12 ++++++++++-- ...brillig_true_inliner_9223372036854775807.snap | 12 ++++++++++-- ...rillig_true_inliner_-9223372036854775808.snap | 16 ++++++++++++++-- ...ute__tests__force_brillig_true_inliner_0.snap | 16 ++++++++++++++-- ...brillig_true_inliner_9223372036854775807.snap | 16 ++++++++++++++-- ...rillig_true_inliner_-9223372036854775808.snap | 4 ++-- ...ute__tests__force_brillig_true_inliner_0.snap | 4 ++-- ...brillig_true_inliner_9223372036854775807.snap | 4 ++-- ...rillig_true_inliner_-9223372036854775808.snap | 4 ++-- ...ute__tests__force_brillig_true_inliner_0.snap | 4 ++-- ...brillig_true_inliner_9223372036854775807.snap | 4 ++-- 12 files changed, 84 insertions(+), 24 deletions(-) diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index e17d66c6564..4e0735204b7 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -66,6 +66,10 @@ expression: artifact "error_kind": "string", "string": "attempt to add with overflow" }, + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "14225679739041873922": { "error_kind": "string", "string": "Index out of bounds" @@ -84,10 +88,14 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 297 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(3), location: 223 }, Jump { location: 138 }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 145 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 153 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Relative(7), source: Relative(5) }, Store { destination_pointer: Relative(7), source: Direct(32837) }, 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(9) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32838) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 303 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, JumpIf { condition: Relative(3), location: 180 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 190 }, Jump { location: 183 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 189 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Jump { location: 199 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(3), source: Direct(32773) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Store { destination_pointer: Relative(4), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 199 }, JumpIf { condition: Relative(2), location: 202 }, Jump { location: 201 }, Jump { location: 203 }, Jump { location: 203 }, JumpIf { condition: Relative(2), location: 206 }, Jump { location: 205 }, Jump { location: 210 }, JumpIf { condition: Relative(2), location: 209 }, Jump { location: 208 }, Jump { location: 210 }, Jump { location: 210 }, JumpIf { condition: Relative(2), location: 212 }, Jump { location: 213 }, Jump { location: 213 }, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 215 }, JumpIf { condition: Relative(2), location: 218 }, Jump { location: 217 }, Return, JumpIf { condition: Relative(2), location: 220 }, Jump { location: 221 }, Jump { location: 221 }, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 215 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 226 }, Jump { location: 232 }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 228 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 235 }, Jump { location: 231 }, Jump { location: 232 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(3) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(12), location: 239 }, Call { location: 383 }, Load { destination: Relative(12), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, JumpIf { condition: Relative(14), location: 244 }, Call { location: 386 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, JumpIf { condition: Relative(14), location: 247 }, Call { location: 389 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Load { destination: Relative(12), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 254 }, Call { location: 389 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 361 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Store { destination_pointer: Relative(16), source: Relative(14) }, Store { destination_pointer: Relative(7), source: Relative(13) }, Mov { destination: Relative(4), source: Direct(32835) }, Jump { location: 264 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(11), location: 284 }, Jump { location: 267 }, Load { destination: Relative(4), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, JumpIf { condition: Relative(11), location: 271 }, Jump { location: 281 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Load { destination: Relative(11), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 281 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 228 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 293 }, Call { location: 383 }, Store { destination_pointer: Relative(2), source: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Mov { destination: Relative(4), source: Relative(11) }, Jump { location: 264 }, 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: 302 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 297 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 309 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 314 }, Jump { location: 312 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 322 }, Jump { location: 319 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 309 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 329 }, Call { location: 389 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 335 }, Jump { location: 358 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 358 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 316 }, 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: 365 }, Jump { location: 367 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 382 }, 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: 379 }, 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: 372 }, 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: 382 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 393 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 319 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Direct(32838) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(8) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(7), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 180 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 190 }, Jump { location: 184 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(7), rhs: Relative(1) }, JumpIf { condition: Relative(8), location: 189 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(7), location: 206 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, JumpIf { condition: Relative(5), location: 214 }, Jump { location: 211 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(7), source: Relative(1) }, Jump { location: 226 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 226 }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 233 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 240 }, Call { location: 479 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(7), location: 256 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(5), location: 264 }, Jump { location: 261 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(7) }, JumpIf { condition: Relative(5), location: 277 }, Jump { location: 274 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 279 }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 285 }, Jump { location: 287 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 287 }, Load { destination: Relative(4), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 292 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 306 }, Jump { location: 300 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 305 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 313 }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Store { destination_pointer: Relative(1), source: Relative(4) }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 322 }, Jump { location: 328 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 324 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 331 }, Jump { location: 327 }, Jump { location: 328 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 335 }, Call { location: 482 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 340 }, Call { location: 485 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 343 }, Call { location: 488 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 350 }, Call { location: 488 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 457 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 360 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 380 }, Jump { location: 363 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 367 }, Jump { location: 377 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 377 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 324 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 389 }, Call { location: 482 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 360 }, 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: 398 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 393 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 405 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 410 }, Jump { location: 408 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 412 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 418 }, Jump { location: 415 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 405 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 425 }, Call { location: 488 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 431 }, Jump { location: 454 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 454 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 412 }, 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: 461 }, Jump { location: 463 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 478 }, 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: 475 }, 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: 468 }, 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: 478 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZfNbtswEITfxWcfyOXfsq8SBIGTKIUBwwkcu0AR+N27I+0oySFAQV88nyTPiOSuaOtj8zw9Xn4/7I8vr++bX3cfm8fT/nDY/344vD7tzvvXo5392AR8xGgSt6bRVVyTa3YtrtW1uaprX1Q8TzxPPE88TzxPPE88TzxPPE88L9n3BGrnE9TOZ9McXO0+BSquyTW7Fle7T4U2V3Xti5bgGl3F1fIaNLsW1+raXNW1L1qDa3QVV8+rnlc9r3petTyFqmtftAXX6CquydXyOrS4Yl0DoBGU0B0UtcIiK4qD1dVMKIRKaAR16LCjBh21xiJ3ISRCJhRCJbQFZG6NCkCyLYIkmYstKH5UQCU0ghK6AzoidkAkCCERMqEQKsGSJQCU0B3QGwtEghASwZIlAgqhEhpBCd0BXbJAJCBHAHBhEdAJYsssKP0CQkjLOqH4sxbX6tpc1bUvqtGVN0O5F8CgURSUewEldB8Q6r5AJAghEfICKQAqoBAqAYFW7oQ9RxSASx3Q/Qy2j/kMmiQFQCYUQiU0ghIwYVvWlAIhEtBjAigE5GDMaLIFlIAcW/GEJlsgEpBTAImQCYVQCY2gBM50brIZIoHLMjfZDJlQCJWAMun1ut1wk384n6YJe/yXXd9+C952p+l43vw6Xg6H7ebP7nCZv/T+tjvOet6d7Kot3nR8NrXAl/1hAl23n+7wszWH5uYcy2ov/+8vSn8NA/6WOPiW8oBfA/0a9DZ/TCN+4fppGlm/jrac/X3Mj+3Q/W3EXzj/XvKN/j7ib6u/1QF/DDl5QAzlxw6I8nOE7dCeYFvv0BDWGsQgYSxB1oQ4sgwlsI1KHCljyZH+LCP+WulvccTf+BgVHZp/K6u/DY1/nX8bmX+NHH+NIz1UM9evliF/5/1bGJl/LfGm+9/6DJW1fEObgHL29u925Eeor78hI1uYfj79Qw9/Wf39ttuP2GNi59lb2oi/rsOvQ/df/0DYW9c3/70d7Z72p28vwlcknfa7x8Pkhy+X49OXq+e/b7zCF+m30+vT9Hw5TUj6fJu2j7tkz31Subf/ZHbUwzaGYAd4z74Te6ZSwDW8bt8lrfZVvb9iZP8A", + "debug_symbols": "pZnNTmM5EIXfJess/Fcuu18FtVoBQitSFFAaRhoh3n18ruvcCwtGrcqG8yWhzi2Xyz+E993j8f7t96/T5en5z+7H3fvu/no6n0+/f52fHw6vp+fLePd9F/AjxiFxPzSaJtNsWkzFtJqqaTPtU5P5JfNL5pfML5lfMr9kfsn8kvkl88vj9xJ0vJ+h4/0ytATT8RyBJtNsWkzFdDynQtW0mfapEkyjaTIdfgotpmJaTdW0mfapNZhG02RqftX8qvlV86vDr0GbaZ+qwTSaJtNsOvw6VExR1wBQQiN0g4a5QpEbJgXVbUKoBCU0g44olL5jilHbngiZUAhCqAQlII1R4hRgqIBIgGEDZEIhCAGGHaCEZoBeTgGQCCM8JYAQKkEJjdAN0MsTIgGGGZAJhVDtWejkVACNAMMx5JQDIRISIRMKQQiVoIRGoHOhc6EzFkRCebEiJhSCECpBCY3QDbAwEiYFK2MCnDEFWBsTCkEIcMZcYH1MaAZYERmFwpKYMMJzBAihEpTQCN0AK2JCJMAH04RFMAHhmB30fMZcoOcz6tMiAWlgpGj+jAGi5yfgoRhO6wZo/gmRgHCMC80/YaRRMC60ehmJZXR4SYARVTIgETKhECqjEF4AjdANsGsXAWRzRodPqAT88hhXRosWBcw9NKP7SgMkQiYUghDg1wFKaIRusGzGC0RCImA/DoBCEEIlKKERugG6T1AMdN+ERMiEQhBCJagBtmNBVbD/CoqAphPUEi02oRH6rNPSYdBomkyzaTEVU53a+DD02AQkjflqmVAIYglhy52ghEboBmg/QEFHSQVEQiLAUAEIH1NYsA1KBwjfaXwHx98odMFeNyESEiETCmH41AioBCXgXB1DLmiyCfBBzmiyCYUAnwKoBCXARwDdAE02IRISIRMKgSNdmmwBJbAsS5MBliZbIBISAdPUPj72O96dfr1ej0dcnT5dpsYV6+VwPV5edz8ub+fzfvfP4fy2/NKfl8Nl0dfDdXw6ine8PA4dhk+n8xH0sd+iw/ehJagFj2lcw+Xv4zGeGV+DI14zk9dcHPEtML6Fdlt8zJ74xPq17Klfx/GxxHdfPK4mFq+eeOH4u5Qb47snXtd4rY74GHC6LQYxyLcdENP3FkmTOSRtrhTWOYghBZ9DWh2iqwwRm/R0GJd8l0Nrq0NPNzt4mnH8ecfVNNA1iryux4EuhyRbDvrtKFL8vyRwZlkSn7o69r9Pom8OwdVSWdaWGum4HIre6qBbDtpdDn1z6PVGh3Gr8TiUvLb1uDZ4HGrkJj9QXDng+mE5VFcOsm0x4jrpxncVax2k+OqQ1xxqdi3OKlsl5WaH6qpD1bUO1dfVta8OGjyn7vheZl2bWlx1UNly8NVB27pHaXMdGC2tc9Gya3W3bV00da1u7evB2Xw77RcHz+qWwDJI9HSDFE6EFM88SOUAxFVDUTajtOqKlzVeXfmv41fP+Ot666iuS0ctrJ9vT6qdz9fgGX+VeNPzb70Ayzp9vjW8bmXd033a1z8APX9/tO3q7rq5r/tP6Lc93nc/qtvlxncarkeZ71axHYVfy/dzvDo8nK5f/jn0Aafr6XB/PtrLp7fLw6dPX/994Sf859LL9fnh+Ph2PcJp+w/T+HFXxk29aPs5vsEar3rYxxDGC3yLeZd73ueOz/C1/V1psi9Nf34gs/8A", "file_map": { + "19": { + "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", + "path": "std/hash/mod.nr" + }, "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", "path": "" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap index e17d66c6564..4e0735204b7 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap @@ -66,6 +66,10 @@ expression: artifact "error_kind": "string", "string": "attempt to add with overflow" }, + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "14225679739041873922": { "error_kind": "string", "string": "Index out of bounds" @@ -84,10 +88,14 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 297 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(3), location: 223 }, Jump { location: 138 }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(8) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 145 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 153 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Relative(7), source: Relative(5) }, Store { destination_pointer: Relative(7), source: Direct(32837) }, 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(9) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32838) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 303 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, JumpIf { condition: Relative(3), location: 180 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 190 }, Jump { location: 183 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 189 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Jump { location: 199 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(3), source: Direct(32773) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Store { destination_pointer: Relative(4), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 199 }, JumpIf { condition: Relative(2), location: 202 }, Jump { location: 201 }, Jump { location: 203 }, Jump { location: 203 }, JumpIf { condition: Relative(2), location: 206 }, Jump { location: 205 }, Jump { location: 210 }, JumpIf { condition: Relative(2), location: 209 }, Jump { location: 208 }, Jump { location: 210 }, Jump { location: 210 }, JumpIf { condition: Relative(2), location: 212 }, Jump { location: 213 }, Jump { location: 213 }, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 215 }, JumpIf { condition: Relative(2), location: 218 }, Jump { location: 217 }, Return, JumpIf { condition: Relative(2), location: 220 }, Jump { location: 221 }, Jump { location: 221 }, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 215 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 226 }, Jump { location: 232 }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 228 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 235 }, Jump { location: 231 }, Jump { location: 232 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(3) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(12), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(12), location: 239 }, Call { location: 383 }, Load { destination: Relative(12), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(13), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(9) }, JumpIf { condition: Relative(14), location: 244 }, Call { location: 386 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Direct(32838) }, JumpIf { condition: Relative(14), location: 247 }, Call { location: 389 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Load { destination: Relative(12), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(8) }, JumpIf { condition: Relative(13), location: 254 }, Call { location: 389 }, Mov { destination: Direct(32771), source: Relative(12) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 361 }, Mov { destination: Relative(13), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Store { destination_pointer: Relative(16), source: Relative(14) }, Store { destination_pointer: Relative(7), source: Relative(13) }, Mov { destination: Relative(4), source: Direct(32835) }, Jump { location: 264 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(11), location: 284 }, Jump { location: 267 }, Load { destination: Relative(4), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, JumpIf { condition: Relative(11), location: 271 }, Jump { location: 281 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Load { destination: Relative(11), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(12), source: Direct(32773) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, Store { destination_pointer: Relative(13), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 281 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 228 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(13) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 293 }, Call { location: 383 }, Store { destination_pointer: Relative(2), source: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Mov { destination: Relative(4), source: Relative(11) }, Jump { location: 264 }, 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: 302 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 297 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 309 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 314 }, Jump { location: 312 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 322 }, Jump { location: 319 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 309 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 329 }, Call { location: 389 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 335 }, Jump { location: 358 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 361 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 358 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 316 }, 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: 365 }, Jump { location: 367 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 382 }, 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: 379 }, 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: 372 }, 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: 382 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 393 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 319 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Direct(32838) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(8) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(7), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 180 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 190 }, Jump { location: 184 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(7), rhs: Relative(1) }, JumpIf { condition: Relative(8), location: 189 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(7), location: 206 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, JumpIf { condition: Relative(5), location: 214 }, Jump { location: 211 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(7), source: Relative(1) }, Jump { location: 226 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 226 }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 233 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 240 }, Call { location: 479 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(7), location: 256 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(5), location: 264 }, Jump { location: 261 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(7) }, JumpIf { condition: Relative(5), location: 277 }, Jump { location: 274 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 279 }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 285 }, Jump { location: 287 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 287 }, Load { destination: Relative(4), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 292 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 306 }, Jump { location: 300 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 305 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 313 }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Store { destination_pointer: Relative(1), source: Relative(4) }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 322 }, Jump { location: 328 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 324 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 331 }, Jump { location: 327 }, Jump { location: 328 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 335 }, Call { location: 482 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 340 }, Call { location: 485 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 343 }, Call { location: 488 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 350 }, Call { location: 488 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 457 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 360 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 380 }, Jump { location: 363 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 367 }, Jump { location: 377 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 377 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 324 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 389 }, Call { location: 482 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 360 }, 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: 398 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 393 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 405 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 410 }, Jump { location: 408 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 412 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 418 }, Jump { location: 415 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 405 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 425 }, Call { location: 488 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 431 }, Jump { location: 454 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 454 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 412 }, 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: 461 }, Jump { location: 463 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 478 }, 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: 475 }, 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: 468 }, 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: 478 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZfNbtswEITfxWcfyOXfsq8SBIGTKIUBwwkcu0AR+N27I+0oySFAQV88nyTPiOSuaOtj8zw9Xn4/7I8vr++bX3cfm8fT/nDY/344vD7tzvvXo5392AR8xGgSt6bRVVyTa3YtrtW1uaprX1Q8TzxPPE88TzxPPE88TzxPPE88L9n3BGrnE9TOZ9McXO0+BSquyTW7Fle7T4U2V3Xti5bgGl3F1fIaNLsW1+raXNW1L1qDa3QVV8+rnlc9r3petTyFqmtftAXX6CquydXyOrS4Yl0DoBGU0B0UtcIiK4qD1dVMKIRKaAR16LCjBh21xiJ3ISRCJhRCJbQFZG6NCkCyLYIkmYstKH5UQCU0ghK6AzoidkAkCCERMqEQKsGSJQCU0B3QGwtEghASwZIlAgqhEhpBCd0BXbJAJCBHAHBhEdAJYsssKP0CQkjLOqH4sxbX6tpc1bUvqtGVN0O5F8CgURSUewEldB8Q6r5AJAghEfICKQAqoBAqAYFW7oQ9RxSASx3Q/Qy2j/kMmiQFQCYUQiU0ghIwYVvWlAIhEtBjAigE5GDMaLIFlIAcW/GEJlsgEpBTAImQCYVQCY2gBM50brIZIoHLMjfZDJlQCJWAMun1ut1wk384n6YJe/yXXd9+C952p+l43vw6Xg6H7ebP7nCZv/T+tjvOet6d7Kot3nR8NrXAl/1hAl23n+7wszWH5uYcy2ov/+8vSn8NA/6WOPiW8oBfA/0a9DZ/TCN+4fppGlm/jrac/X3Mj+3Q/W3EXzj/XvKN/j7ib6u/1QF/DDl5QAzlxw6I8nOE7dCeYFvv0BDWGsQgYSxB1oQ4sgwlsI1KHCljyZH+LCP+WulvccTf+BgVHZp/K6u/DY1/nX8bmX+NHH+NIz1UM9evliF/5/1bGJl/LfGm+9/6DJW1fEObgHL29u925Eeor78hI1uYfj79Qw9/Wf39ttuP2GNi59lb2oi/rsOvQ/df/0DYW9c3/70d7Z72p28vwlcknfa7x8Pkhy+X49OXq+e/b7zCF+m30+vT9Hw5TUj6fJu2j7tkz31Subf/ZHbUwzaGYAd4z74Te6ZSwDW8bt8lrfZVvb9iZP8A", + "debug_symbols": "pZnNTmM5EIXfJess/Fcuu18FtVoBQitSFFAaRhoh3n18ruvcCwtGrcqG8yWhzi2Xyz+E993j8f7t96/T5en5z+7H3fvu/no6n0+/f52fHw6vp+fLePd9F/AjxiFxPzSaJtNsWkzFtJqqaTPtU5P5JfNL5pfML5lfMr9kfsn8kvkl88vj9xJ0vJ+h4/0ytATT8RyBJtNsWkzFdDynQtW0mfapEkyjaTIdfgotpmJaTdW0mfapNZhG02RqftX8qvlV86vDr0GbaZ+qwTSaJtNsOvw6VExR1wBQQiN0g4a5QpEbJgXVbUKoBCU0g44olL5jilHbngiZUAhCqAQlII1R4hRgqIBIgGEDZEIhCAGGHaCEZoBeTgGQCCM8JYAQKkEJjdAN0MsTIgGGGZAJhVDtWejkVACNAMMx5JQDIRISIRMKQQiVoIRGoHOhc6EzFkRCebEiJhSCECpBCY3QDbAwEiYFK2MCnDEFWBsTCkEIcMZcYH1MaAZYERmFwpKYMMJzBAihEpTQCN0AK2JCJMAH04RFMAHhmB30fMZcoOcz6tMiAWlgpGj+jAGi5yfgoRhO6wZo/gmRgHCMC80/YaRRMC60ehmJZXR4SYARVTIgETKhECqjEF4AjdANsGsXAWRzRodPqAT88hhXRosWBcw9NKP7SgMkQiYUghDg1wFKaIRusGzGC0RCImA/DoBCEEIlKKERugG6T1AMdN+ERMiEQhBCJagBtmNBVbD/CoqAphPUEi02oRH6rNPSYdBomkyzaTEVU53a+DD02AQkjflqmVAIYglhy52ghEboBmg/QEFHSQVEQiLAUAEIH1NYsA1KBwjfaXwHx98odMFeNyESEiETCmH41AioBCXgXB1DLmiyCfBBzmiyCYUAnwKoBCXARwDdAE02IRISIRMKgSNdmmwBJbAsS5MBliZbIBISAdPUPj72O96dfr1ej0dcnT5dpsYV6+VwPV5edz8ub+fzfvfP4fy2/NKfl8Nl0dfDdXw6ine8PA4dhk+n8xH0sd+iw/ehJagFj2lcw+Xv4zGeGV+DI14zk9dcHPEtML6Fdlt8zJ74xPq17Klfx/GxxHdfPK4mFq+eeOH4u5Qb47snXtd4rY74GHC6LQYxyLcdENP3FkmTOSRtrhTWOYghBZ9DWh2iqwwRm/R0GJd8l0Nrq0NPNzt4mnH8ecfVNNA1iryux4EuhyRbDvrtKFL8vyRwZlkSn7o69r9Pom8OwdVSWdaWGum4HIre6qBbDtpdDn1z6PVGh3Gr8TiUvLb1uDZ4HGrkJj9QXDng+mE5VFcOsm0x4jrpxncVax2k+OqQ1xxqdi3OKlsl5WaH6qpD1bUO1dfVta8OGjyn7vheZl2bWlx1UNly8NVB27pHaXMdGC2tc9Gya3W3bV00da1u7evB2Xw77RcHz+qWwDJI9HSDFE6EFM88SOUAxFVDUTajtOqKlzVeXfmv41fP+Ot666iuS0ctrJ9vT6qdz9fgGX+VeNPzb70Ayzp9vjW8bmXd033a1z8APX9/tO3q7rq5r/tP6Lc93nc/qtvlxncarkeZ71axHYVfy/dzvDo8nK5f/jn0Aafr6XB/PtrLp7fLw6dPX/994Sf859LL9fnh+Ph2PcJp+w/T+HFXxk29aPs5vsEar3rYxxDGC3yLeZd73ueOz/C1/V1psi9Nf34gs/8A", "file_map": { + "19": { + "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", + "path": "std/hash/mod.nr" + }, "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", "path": "" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index f5bd611e4d9..3609e99d16d 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -66,6 +66,10 @@ expression: artifact "error_kind": "string", "string": "attempt to add with overflow" }, + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "14225679739041873922": { "error_kind": "string", "string": "Index out of bounds" @@ -84,10 +88,14 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 361 }, 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(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 121 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 115 }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(13), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Relative(2) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 287 }, Jump { location: 138 }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(4), source_pointer: Relative(7) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(4) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(5), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(9), source: Relative(8) }, Store { destination_pointer: Relative(9), source: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(5) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(11) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(12) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Mov { destination: Relative(3), source: Relative(10) }, Jump { location: 172 }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(7), location: 240 }, Jump { location: 175 }, Load { destination: Relative(3), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 182 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 192 }, Jump { location: 185 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 191 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Jump { location: 201 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 367 }, Mov { destination: Relative(3), source: Direct(32773) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 201 }, JumpIf { condition: Relative(4), location: 204 }, Jump { location: 203 }, Jump { location: 205 }, Jump { location: 205 }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 207 }, JumpIf { condition: Relative(4), location: 229 }, Jump { location: 209 }, JumpIf { condition: Relative(4), location: 212 }, Jump { location: 211 }, Jump { location: 216 }, JumpIf { condition: Relative(4), location: 215 }, Jump { location: 214 }, Jump { location: 216 }, Jump { location: 216 }, JumpIf { condition: Relative(4), location: 218 }, Jump { location: 219 }, Jump { location: 219 }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 221 }, JumpIf { condition: Relative(4), location: 224 }, Jump { location: 223 }, Return, JumpIf { condition: Relative(4), location: 226 }, Jump { location: 227 }, Jump { location: 227 }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 221 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 231 }, JumpIf { condition: Relative(4), location: 235 }, Jump { location: 233 }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 207 }, JumpIf { condition: Relative(4), location: 237 }, Jump { location: 238 }, Jump { location: 238 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 231 }, Mov { destination: Relative(7), source: Relative(2) }, Jump { location: 242 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, JumpIf { condition: Relative(8), location: 248 }, Jump { location: 245 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Mov { destination: Relative(3), source: Relative(7) }, Jump { location: 172 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 255 }, Call { location: 389 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(7) }, Load { destination: Relative(14), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(14) }, JumpIf { condition: Relative(8), location: 261 }, Jump { location: 284 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(7) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 367 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(7) }, Store { destination_pointer: Relative(17), source: Relative(14) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 367 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Store { destination_pointer: Relative(16), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 284 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(10) }, Mov { destination: Relative(7), source: Relative(8) }, Jump { location: 242 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 290 }, Jump { location: 296 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 292 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 299 }, Jump { location: 295 }, Jump { location: 296 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(3) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 303 }, Call { location: 392 }, Load { destination: Relative(16), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(17), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Relative(3) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(18), location: 308 }, Call { location: 395 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 311 }, Call { location: 389 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(17) }, Load { destination: Relative(18), source_pointer: Relative(20) }, Load { destination: Relative(16), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(9) }, JumpIf { condition: Relative(17), location: 318 }, Call { location: 389 }, Mov { destination: Direct(32771), source: Relative(16) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 367 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(19), rhs: Relative(15) }, Store { destination_pointer: Relative(20), source: Relative(18) }, Store { destination_pointer: Relative(8), source: Relative(17) }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 328 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(15), location: 348 }, Jump { location: 331 }, Load { destination: Relative(4), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(14) }, JumpIf { condition: Relative(15), location: 335 }, Jump { location: 345 }, Load { destination: Relative(4), source_pointer: Relative(7) }, Load { destination: Relative(15), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 367 }, Mov { destination: Relative(16), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Store { destination_pointer: Relative(17), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(16) }, Jump { location: 345 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 292 }, Load { destination: Relative(15), source_pointer: Relative(7) }, Load { destination: Relative(16), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(19) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(17) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(15), rhs: Relative(16) }, JumpIf { condition: Relative(18), location: 357 }, Call { location: 392 }, Store { destination_pointer: Relative(7), source: Relative(16) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Mov { destination: Relative(4), source: Relative(15) }, Jump { location: 328 }, 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: 366 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, 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: 371 }, Jump { location: 373 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 388 }, 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: 385 }, 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: 378 }, 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: 388 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 491 }, 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(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 121 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 115 }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(13), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Relative(2) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(15), location: 417 }, Jump { location: 138 }, Load { destination: Relative(14), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(9) }, Load { destination: Relative(8), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 145 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Load { destination: Relative(8), source_pointer: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(7) }, JumpIf { condition: Relative(8), location: 153 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, 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(14), source: Relative(9) }, Store { destination_pointer: Relative(14), source: Relative(10) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(7) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(8) }, Mov { destination: Relative(5), source: Relative(10) }, Jump { location: 172 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(8), location: 370 }, Jump { location: 175 }, Load { destination: Relative(5), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Load { destination: Relative(8), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 182 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 192 }, Jump { location: 186 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(9), location: 191 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Jump { location: 201 }, Load { destination: Relative(8), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(10) }, Store { destination_pointer: Relative(14), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Jump { location: 201 }, Load { destination: Relative(8), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, JumpIf { condition: Relative(8), location: 208 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, JumpIf { condition: Relative(5), location: 216 }, Jump { location: 213 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(8), source: Relative(1) }, Jump { location: 228 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(9), size: Relative(14) }, output: HeapArray { pointer: Relative(15), size: 32 } }), BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Store { destination_pointer: Relative(8), source: Relative(3) }, Jump { location: 228 }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Load { destination: Relative(8), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(3), rhs: Relative(8) }, JumpIf { condition: Relative(4), location: 235 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(3), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 242 }, Call { location: 519 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, 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: Relative(3) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 249 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 323 }, Jump { location: 252 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 260 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, JumpIf { condition: Relative(5), location: 268 }, Jump { location: 265 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 283 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Store { destination_pointer: Relative(9), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, JumpIf { condition: Relative(5), location: 281 }, Jump { location: 278 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 283 }, Store { destination_pointer: Relative(3), source: Relative(7) }, Jump { location: 283 }, Load { destination: Relative(1), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 289 }, Jump { location: 291 }, Store { destination_pointer: Relative(3), source: Relative(11) }, Jump { location: 291 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, JumpIf { condition: Relative(3), location: 296 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 301 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 310 }, Jump { location: 304 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 309 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, 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(5), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 317 }, Jump { location: 320 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(7) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 320 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 301 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 325 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(8), location: 331 }, Jump { location: 328 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 249 }, Load { destination: Relative(8), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 338 }, Call { location: 522 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Load { destination: Relative(14), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(14) }, JumpIf { condition: Relative(8), location: 344 }, Jump { location: 367 }, Load { destination: Relative(8), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Store { destination_pointer: Relative(17), source: Relative(14) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Store { destination_pointer: Relative(16), source: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(8) }, Jump { location: 367 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Mov { destination: Relative(3), source: Relative(8) }, Jump { location: 325 }, Mov { destination: Relative(8), source: Relative(2) }, Jump { location: 372 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, JumpIf { condition: Relative(14), location: 378 }, Jump { location: 375 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(8) }, Jump { location: 172 }, Load { destination: Relative(14), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 385 }, Call { location: 522 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(8) }, Load { destination: Relative(16), source_pointer: Relative(18) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(16) }, JumpIf { condition: Relative(14), location: 391 }, Jump { location: 414 }, Load { destination: Relative(14), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(8) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Store { destination_pointer: Relative(18), source: Relative(15) }, Store { destination_pointer: Relative(9), source: Relative(14) }, Jump { location: 414 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 372 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 420 }, Jump { location: 426 }, Mov { destination: Relative(15), source: Relative(2) }, Jump { location: 422 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 429 }, Jump { location: 425 }, Jump { location: 426 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(15) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 433 }, Call { location: 525 }, Load { destination: Relative(18), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 438 }, Call { location: 528 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(19), rhs: Relative(12) }, JumpIf { condition: Relative(20), location: 441 }, Call { location: 522 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(19) }, Load { destination: Relative(20), source_pointer: Relative(22) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(9) }, JumpIf { condition: Relative(19), location: 448 }, Call { location: 522 }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 497 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(20) }, Store { destination_pointer: Relative(8), source: Relative(19) }, Mov { destination: Relative(16), source: Relative(2) }, Jump { location: 458 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, JumpIf { condition: Relative(17), location: 478 }, Jump { location: 461 }, Load { destination: Relative(16), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, JumpIf { condition: Relative(17), location: 465 }, Jump { location: 475 }, Load { destination: Relative(16), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Store { destination_pointer: Relative(6), source: Relative(18) }, Jump { location: 475 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Mov { destination: Relative(15), source: Relative(16) }, Jump { location: 422 }, Load { destination: Relative(17), source_pointer: Relative(7) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(16) }, Load { destination: Relative(19), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(17), rhs: Relative(18) }, JumpIf { condition: Relative(20), location: 487 }, Call { location: 525 }, Store { destination_pointer: Relative(7), source: Relative(18) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Mov { destination: Relative(16), source: Relative(17) }, Jump { location: 458 }, 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: 496 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, 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: 501 }, Jump { location: 503 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 518 }, 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: 515 }, 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: 508 }, 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: 518 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZfBbtswEET/xWcfuCSXS+ZXiiBwEqUwYDiBYxcoAv97OdKOkh5cFMzF82R5RuSSWksfm+fp8fLzYX98eX3f3P342Dye9ofD/ufD4fVpd96/Hvu3H5uADwllcyfbruZaXduiElzFNbom1+yqrp4nnieeJ54XPS96XvS86HnR86LnRc9L/ThCe16C9rzcNQfXnqfQ6Jpcs6u69rwCNdfq2hbV4Cqu0bXnGTS7qmtxNdfq2hYtwVVco6vnFc8rnlc8r/S8Bq2ubVFDvQIABUJlDBVCacwIqDmKZM2hBoIQkIPCVeRghrUQjFAJzaEFAuwYZ8O6VUAmKKEQjFAJbYGI5ZIG8OlELMjyTf9N7DONWJIFhBAJiZAJ2CfIwcIsYISeHHt9ItZiAeQkQCJkAnIyoBCMgBwFNAcLBCFEQiJkAmc6L9wMRqiE5jAv3AxCiIRMwMD6okQsSjRAmW+SiDLHXuYUAkEIkZAIGGADKKEQjFAJzQH9YYGenAIgEhIhE5RQCEbAfS2A5oBOsYAQIiERMkEJyOlrmxJcCQBXBiihEGyuU/KmktBUoGgqs4prdE2u6sqLYa/OgL2aFCCESEg+IOzVBZRQCEZAcrpetxv27IfzaZrQsr808d7a33an6Xje3B0vh8N282t3uMw/en/bHWc97079bK/wdHzu2gNf9ocJdN1+usNtaw7m5iy62vX//VrpL2HAb4mDt5QH/DXQX0P9nl/SiD+yfjWN1K9hp87+NuZHM3W/3fLX2/7eytzf29OAX9XtWgbc/c/I7dJkZPbK1Wuav+lvI35b/VYG/BJyYgGC3qy/6DcX8J9DWHeQhBjGEuKaICPbwNp6Dw+4W/0c/8geDLr62/cuP2KXVOjPI7Pvj5b0l6Hrrw28P7wOrL4GNjCVkVtQs9Cfh65fWD+1kRaixhaktQz51w5YbWj86/xtZP5FOP4iI/d/yaxf0SF/4/UtjMy/qNy4/n0/2j3tT3+9116RdNrvHg+TH75cjk9fzp5/v/EM34vfTq9P0/PlNCHp8+W4f/xIxbap1vv+TNaPWthKCPd4P57PyTaVgkPBYdNtanZ/xcj+AA==", + "debug_symbols": "pZnNbhs5EITfRWcf+NPNJvMqgREojrIQIMiGYi+wCPzuyxp2zSQHGQbn4v4kuWvIZk2TI/0+/Dh9f/vn2/n68/nX4cvX34fvt/Plcv7n2+X56fh6fr72d38fAv7EUA5f4kOP5rF6bCPG4DF6TB6zR/GoHl0vul50veh6yfWS6yXXS66XXC+5XnK93F8nxK6XEbue9CjBY9dTxOQxexSP6rHrFUTzWD22ETV4jB6Tx65niOJRPRaP5rF6bCOW4DF6TB5dr7hecb3ieqXrNcTqsY1oqFcAoECojKFCKI0ZATVHkaw51ECIBOigcBXpmGE1QiU0hxYIyMLwGparAoSghEIwQiW0ASlgGA3QBVMAZEIXTBGghEIwQhdMCdAcYNMB0MkAISBdAUaohOYAVw6IhETIBAgWgBIKofq1EgR7fVIOBAhiyjkRMkEISigEI1RCc4DhB1BZqCxUhukzignXDyiErpNRQxg7o2JwdsJawNoZs4C3ByBLAEaohOYAg2fUBw4fkAjQQX1g6gFIR1lg5wUsECIhETJBCEqADmYKhy8AY2fMovYswUxrzxLMtCqhD0MwZRhbMMEWCf2igunA2AOEoASkY14w9oA+DOnzyvCzGABZFYCsBigEI1QHmHbJQnPVAEiETED/igBzZbh3AZh2AHpbAtSxphmuW96B6zQDMkEISigEI3QdFUBzgOsGQFkBQoAOigCPDTACdDBBuG4BtNcB0MHg4cMBmSAEJRSCETjTxYeAxYcLREIiZIIQlGAOcJ1iUdhXMzw23sHWgLVAFx0QCYmQCULoOgU6cN0AI2DPwUVhvwHQQeVhvwFCgA4qD/sNMAJ0sAToqwAJgRAJiZAJQvCZynIGWMAIldAclnPAApGQCELAwPq6C5pnMUBZdmtBXyx93QR9cUAkJEImYIANoIRCMEIlNAc4dAB22gBIhEwQghIKwQjYwDEbeHYBeHZAJCRCJghBCdDpayvLzo8iLFu/AJRQCDbqVKrHNuLSHRGjx+Qxe1SPvBi8ugC8alhleHVAImQfELw6QAmFYAQo5/f3hwMPj99eb6cTzo5/nCb7GfPleDtdXw9frm+Xy8Ph3+PlbfmnXy/H6xJfj7f+aa/w6fqjxy7483w5gd4ftuxwP7W705Ml6pqun89H4xj5JUzkW+bgLctEfg3Mr6Huy495Jj+xfjXP1K9hu1/y21w+Dnyeb/fy6/38BF8v+X37n8jHZrWka5nI7sdjT48tzsxeuXpNZWd+m8m3Nd/KRH4MOCeNAgS9W/+oOxfwwyGsDoohhTmFtCrEqTJEHGyGQn82m1KodVVoabeCzSikuLq5Pw3NKOS1m3ScUki6jcHuziLJR4PAccoH8YerY/v8INqmEKYslXW1VB/OlILYXgXbxmB3uwMe8nbdmx8JfKK7fpS+t73274O2ErSyU6Efn2cUJK/3ZT+XziiUyD22o06Noeg6hjI1Bt16pE4dNPp3ZGsdVObqkNcxlDzVXYpuldTdCmWqDsXWOhSbq0NbFSzMHBuibc3FZKoOptsY5upgdW2yVqd2vJrWtah56u6u231Rberutrbu/HVuq/hLQWfapLX1EWImfXNTSFNdOqxFDG3nAKbyYy5bj54S2GxQ5kaw3Q0lTTxHfGIF674FrDvXr+5bvrpz9erOxas71+6DG1gDu5DGmWaswj6oMnX9wvrpVAtT416gtUzlr4e8alPjX+dvM/Mv61NLmXpoKcL6zR0JSuP1LczMv2i8c/3H/ur4dL799QvtO5Ru5+P3y8lf/ny7Pv3x6et/L/yEv/C+3J6fTj/ebicobT/z9j9fpY9eY33s3xf3Vy08xBAe8Uvv8ll8kFbwsn9d+FX7r0iaw+M7RvY/", "file_map": { + "19": { + "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", + "path": "std/hash/mod.nr" + }, "50": { "source": "fn sort(mut a: [u32; 4]) -> [u32; 4] {\n for i in 1..4 {\n for j in 0..i {\n if a[i] < a[j] {\n let c = a[j];\n a[j] = a[i];\n a[i] = c;\n }\n }\n }\n a\n}\n\nfn must_be_zero(x: u8) {\n assert(x == 0);\n}\n\nfn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //Test case for short-circuit\n let mut data = [0 as u32; 32];\n let mut ba = a;\n for i in 0..32 {\n let i_u32 = i as u32;\n if i_u32 == a {\n for j in 0..4 {\n data[i + j] = c[4 - 1 - j];\n for k in 0..4 {\n ba = ba + data[k];\n }\n if ba == 4864 {\n c[3] = ba;\n }\n }\n }\n }\n assert(data[31] == 0);\n assert(ba != 13);\n //Test case for conditional with arrays from function parameters\n let b = sort([1, 2, 3, 4]);\n assert(b[0] == 1);\n\n if a == 0 {\n must_be_zero(0);\n c[0] = 3;\n } else {\n must_be_zero(1);\n c[0] = 1;\n c[1] = c[2] / a + 11 % a;\n let f1 = a as Field;\n assert(10 / f1 != 0);\n }\n assert(c[0] == 3);\n\n let mut y = 0;\n if a == 0 {\n let digest = std::hash::blake3(x);\n y = digest[0];\n } else {\n y = 5;\n }\n assert(y == result[0]);\n c = sort(c);\n assert(c[0] == 0);\n //test 1\n let mut x: u32 = 0;\n if a == 0 {\n c[0] = 12;\n if a != 0 {\n x = 6;\n } else {\n x = 2;\n assert(x == 2);\n }\n } else {\n x = 5;\n assert(x == 5);\n }\n if c[0] == 0 {\n x = 3;\n }\n assert(x == 2);\n //test2: loops\n let mut x: u32 = 0;\n x = a - a;\n for i in 0..4 {\n if c[i] == 0 {\n x = i as u32 + 2;\n }\n }\n assert(x == 0);\n}\n", "path": "" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index ce476a4872d..301e669f51a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -58,6 +58,10 @@ expression: artifact ], "return_type": null, "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" @@ -72,10 +76,18 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 121 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(5), location: 111 }, Jump { location: 117 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 116 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 117 }, JumpIf { condition: Relative(1), location: 119 }, Jump { location: 120 }, Jump { location: 120 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 126 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32837) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32842 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32847 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 104 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 162 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(6), location: 113 }, Jump { location: 118 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(6), location: 117 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 118 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(7), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Relative(6) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 168 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(7), location: 130 }, Jump { location: 146 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, 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: Direct(32836) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, 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) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 146 }, Load { destination: Relative(6), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 154 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(3) }, Mov { destination: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 178 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 167 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 162 }, Const { destination: Relative(2), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 173 }, Jump { location: 177 }, Const { destination: Relative(1), bit_size: Field, value: 1 }, Const { destination: Relative(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(3), op: Div, lhs: Relative(1), rhs: Relative(2) }, Jump { location: 177 }, Return, Call { location: 162 }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 185 }, Call { location: 207 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(7), size: 32 } }), Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(3) }, Mov { destination: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 210 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, JumpIf { condition: Relative(1), location: 206 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 162 }, 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(32835) }, 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: 220 }, Call { location: 207 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 226 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, JumpIf { condition: Relative(5), location: 231 }, Jump { location: 229 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(5), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 226 }]" ], - "debug_symbols": "jZDdCsMgDIXfJddeGPfH+iqjFNumQxBbnA5G8d0XN7u1F4Pd+BnjOQlnhp7aeG2MG8YbVJcZWm+sNdfGjp0OZnT8OoPMB8ojVCiYpzcRoVKZqnBXuC88MFMSsHg1wRNlq5U5j5y0JxegctFaAXdt4+vTbdLuxaA9d6UAcj2TDQdjKd+S+KrlbylvWMSI54/88L9+d1r0e7XR11zpzvhNXCk7eaNbS6UcoutW3fCYls4S9+THjvroKTt9M+dEL2cpUMo6B88VKhSojnXKw58=", + "debug_symbols": "pZbNbuJAEITfxWcO0z3/vEoURQZMZMkyyIGVVoh33+7QBezBEXIu1Gc8VR7a3caXZtdtzp8f/bg/fDXrt0uzmfph6D8/hsO2PfWHUb69NE4/yJVmTSvRelPyzZpVg2k0Taay3qvK+iDKzpRM2dSbBlPJiarppl58WZVM2dSbBtNomkyzaTGtNw2WFywvWF6wvCB5STWZSk5RLaaSU0WjMyVTNvWmkkNOIQISIAMKoBokB9BvtM7ZASSYtKI5ACIA9gJ7IQADPAAbK9hYwcaKbkyLXgqgGlQHIAADPCAANFmLVxMgAwqg3oCdAxCAAR4QAJbMhMWExYTF2pGUFSIgATKgAKqB9ucNCAAX6xq59+xxSpuQqoIHBIDOgVNIgAyQizIrIFCb8QaaXK7XVYPR+zhNXaeT9zSLMqHHdurGU7Mez8Owav60w/l70dexHb/11E5yVq7WjTtRCdz3Q6d0XT3cbt5KxGaW0b3b4+t+n+EPvMQfK/xp0fVjhD+7Jf6C4slcLPBLG5ufXZnzp3l/YvgTL6kfM+ov7fpL/6LfHzz8qSzw+xDM7+OS/fuE/vUpz/m1x2cDHArgyS/YQAho4DDfwBR+mqCEFpBhetwDGccXtxADahDjknsgT2ncBHlOh0fC60Pg6n0KfF0SQI8ATksCvHvsoPx2B3M/QYd1topM90che/ec8C4H7baf/nvRumrU1LebobPD/XncPp09/T3iDF7UjtNh2+3OU6dJj7c1+Vd6q25Fzr3rK5sckYwFpayH8lfzxtLk7Or7VffyDw==", "file_map": { + "5": { + "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", + "path": "std/cmp.nr" + }, + "19": { + "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", + "path": "std/hash/mod.nr" + }, "50": { "source": "fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //regression for short-circuit2\n if 35 == a {\n assert(false);\n }\n bar(a as Field);\n\n if a == 3 {\n c = test4();\n }\n assert(c[1] != 2);\n call_intrinsic(x, result);\n}\n\nfn foo() {\n let mut x = 1;\n x /= 0;\n}\n\nfn bar(x: Field) {\n if x == 15 {\n foo();\n }\n}\n\nfn call_intrinsic(x: [u8; 5], result: [u8; 32]) {\n let mut digest = std::hash::blake3(x);\n digest[0] = 5 as u8;\n digest = std::hash::blake3(x);\n assert(digest == result);\n}\n\nfn test4() -> [u32; 4] {\n let b: [u32; 4] = [1, 2, 3, 4];\n b\n}\n", "path": "" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap index 590ae6367f3..c1026a7172b 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap @@ -58,6 +58,10 @@ expression: artifact ], "return_type": null, "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" @@ -72,10 +76,18 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 131 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(5), location: 111 }, Jump { location: 117 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 116 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 117 }, JumpIf { condition: Relative(1), location: 119 }, Jump { location: 120 }, Jump { location: 120 }, JumpIf { condition: Relative(1), location: 122 }, Jump { location: 123 }, Jump { location: 123 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 126 }, JumpIf { condition: Relative(1), location: 129 }, Jump { location: 128 }, Return, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 126 }, 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: 136 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 208 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 112 }, Jump { location: 117 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 116 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Jump { location: 117 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 122 }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 132 }, Jump { location: 148 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 148 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 156 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 162 }, Call { location: 214 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 181 }, Call { location: 214 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 187 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 195 }, Jump { location: 190 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 194 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 187 }, 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: 213 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "jZDdDoMgDIXfpddcUN1P5qssxqDWhYSgYbBkMbz7yoZTL5bsho9SzmlzZuipDbdG22G8Q3WdoXXaGH1rzNgpr0fLrzPIdKA8QYWCef4QEaoiscgsMw+ZR2aMAhavxjuiZLUx55GTcmQ9VDYYI+ChTHh/uk/KvumV464UQLZnsuGgDaVbFKta/pbyhlmMePnKj//ry/OiPxQ7fc2V6rTbxRWTk9OqNZTLIdhu0/XPaekscU9u7KgPjpLTmjkner1IgVLWKXiusESB5amOafgL", + "debug_symbols": "tZbNbuowEIXfJess7Bn/8ipVhQKEKlIUUApXukK8+50BH8JdBKFU3XQ+Nz7HHntsfKl27eb8te6G/eG7Wn1cqs3Y9X33te4P2+bUHQb576Uy+seaUK1sLTHeo6VqRRq5RFeiL1H6scZUrbzGfI8kuqiRS3Qlin/SGO+RpZ81CgxwAA8IgAhIgFzAGYAFwNnB2cHZwdmJc9aYSlQ7TdsbgNppop4ADHAAD9CJOoUISIBcIBiABRCAAeocFDwgACIgAXKBaAAWoM66ypEBDqDOmnIMgAhIgFwgGYAFEACqLH1I1zRrH93qTAAGYNAsg5Iub46ABJBBSRaTjAFYgNaiU+D7WGQcQMvRXK91hZpen8a21ZJ+KnIp/WMztsOpWg3nvq+rP01/vnX6PjbDLZ6aUb6KZTvsJIrhvutbpWs9qc281Gol3MRyFh5y/76eI/SOluh9hj4sGt976KOZ07t5PTtX9OztEn3A+nGIc/rwQm+wfmx5Sf4Jm29TWKCXci16MmlOn+f1gaAPtGT/iZA/sf2hflH+jqEPs/lb/kUDb3ACPM2eAOtfHcGAPZDTOC2CnOe35+BQxd7PJxF/0UBuVBxEuVPdZPG2g9zA+VHKnBc52MmBwiIHNtMc0o/nMJcFvdhLS/ZxJRObZ4dPaTTbbvzvJXVVq7FrNn1bmvvzsH36evp7xBe8xI7jYdvuzmOrTtNzTH7nPrKprTGf+iaTllwqNVnWptWmvBfIhs+rzuUf", "file_map": { + "5": { + "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", + "path": "std/cmp.nr" + }, + "19": { + "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", + "path": "std/hash/mod.nr" + }, "50": { "source": "fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //regression for short-circuit2\n if 35 == a {\n assert(false);\n }\n bar(a as Field);\n\n if a == 3 {\n c = test4();\n }\n assert(c[1] != 2);\n call_intrinsic(x, result);\n}\n\nfn foo() {\n let mut x = 1;\n x /= 0;\n}\n\nfn bar(x: Field) {\n if x == 15 {\n foo();\n }\n}\n\nfn call_intrinsic(x: [u8; 5], result: [u8; 32]) {\n let mut digest = std::hash::blake3(x);\n digest[0] = 5 as u8;\n digest = std::hash::blake3(x);\n assert(digest == result);\n}\n\nfn test4() -> [u32; 4] {\n let b: [u32; 4] = [1, 2, 3, 4];\n b\n}\n", "path": "" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 590ae6367f3..c1026a7172b 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -58,6 +58,10 @@ expression: artifact ], "return_type": null, "error_types": { + "12049594436772143978": { + "error_kind": "string", + "string": "array ref-count underflow detected" + }, "17843811134343075018": { "error_kind": "string", "string": "Stack too deep" @@ -72,10 +76,18 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 131 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(5), location: 111 }, Jump { location: 117 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 116 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 117 }, JumpIf { condition: Relative(1), location: 119 }, Jump { location: 120 }, Jump { location: 120 }, JumpIf { condition: Relative(1), location: 122 }, Jump { location: 123 }, Jump { location: 123 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 126 }, JumpIf { condition: Relative(1), location: 129 }, Jump { location: 128 }, Return, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 126 }, 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: 136 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 208 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 112 }, Jump { location: 117 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 116 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Jump { location: 117 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 122 }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 132 }, Jump { location: 148 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 148 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 156 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 162 }, Call { location: 214 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 181 }, Call { location: 214 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 187 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 195 }, Jump { location: 190 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 194 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 187 }, 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: 213 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "jZDdDoMgDIXfpddcUN1P5qssxqDWhYSgYbBkMbz7yoZTL5bsho9SzmlzZuipDbdG22G8Q3WdoXXaGH1rzNgpr0fLrzPIdKA8QYWCef4QEaoiscgsMw+ZR2aMAhavxjuiZLUx55GTcmQ9VDYYI+ChTHh/uk/KvumV464UQLZnsuGgDaVbFKta/pbyhlmMePnKj//ry/OiPxQ7fc2V6rTbxRWTk9OqNZTLIdhu0/XPaekscU9u7KgPjpLTmjkner1IgVLWKXiusESB5amOafgL", + "debug_symbols": "tZbNbuowEIXfJess7Bn/8ipVhQKEKlIUUApXukK8+50BH8JdBKFU3XQ+Nz7HHntsfKl27eb8te6G/eG7Wn1cqs3Y9X33te4P2+bUHQb576Uy+seaUK1sLTHeo6VqRRq5RFeiL1H6scZUrbzGfI8kuqiRS3Qlin/SGO+RpZ81CgxwAA8IgAhIgFzAGYAFwNnB2cHZwdmJc9aYSlQ7TdsbgNppop4ADHAAD9CJOoUISIBcIBiABRCAAeocFDwgACIgAXKBaAAWoM66ypEBDqDOmnIMgAhIgFwgGYAFEACqLH1I1zRrH93qTAAGYNAsg5Iub46ABJBBSRaTjAFYgNaiU+D7WGQcQMvRXK91hZpen8a21ZJ+KnIp/WMztsOpWg3nvq+rP01/vnX6PjbDLZ6aUb6KZTvsJIrhvutbpWs9qc281Gol3MRyFh5y/76eI/SOluh9hj4sGt976KOZ07t5PTtX9OztEn3A+nGIc/rwQm+wfmx5Sf4Jm29TWKCXci16MmlOn+f1gaAPtGT/iZA/sf2hflH+jqEPs/lb/kUDb3ACPM2eAOtfHcGAPZDTOC2CnOe35+BQxd7PJxF/0UBuVBxEuVPdZPG2g9zA+VHKnBc52MmBwiIHNtMc0o/nMJcFvdhLS/ZxJRObZ4dPaTTbbvzvJXVVq7FrNn1bmvvzsH36evp7xBe8xI7jYdvuzmOrTtNzTH7nPrKprTGf+iaTllwqNVnWptWmvBfIhs+rzuUf", "file_map": { + "5": { + "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", + "path": "std/cmp.nr" + }, + "19": { + "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", + "path": "std/hash/mod.nr" + }, "50": { "source": "fn main(a: u32, mut c: [u32; 4], x: [u8; 5], result: pub [u8; 32]) {\n //regression for short-circuit2\n if 35 == a {\n assert(false);\n }\n bar(a as Field);\n\n if a == 3 {\n c = test4();\n }\n assert(c[1] != 2);\n call_intrinsic(x, result);\n}\n\nfn foo() {\n let mut x = 1;\n x /= 0;\n}\n\nfn bar(x: Field) {\n if x == 15 {\n foo();\n }\n}\n\nfn call_intrinsic(x: [u8; 5], result: [u8; 32]) {\n let mut digest = std::hash::blake3(x);\n digest[0] = 5 as u8;\n digest = std::hash::blake3(x);\n assert(digest == result);\n}\n\nfn test4() -> [u32; 4] {\n let b: [u32; 4] = [1, 2, 3, 4];\n b\n}\n", "path": "" diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 0c54966af59..0dfda76646a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -50,9 +50,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32857 }, 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(32856), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32856) }, Call { location: 13 }, Call { location: 35 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32857 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U1), 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(U8), value: 34 }, Const { destination: Direct(32840), bit_size: Integer(U8), value: 44 }, Const { destination: Direct(32841), bit_size: Integer(U8), value: 50 }, Const { destination: Direct(32842), bit_size: Integer(U8), value: 51 }, Const { destination: Direct(32843), bit_size: Integer(U8), value: 58 }, Const { destination: Direct(32844), bit_size: Integer(U8), value: 100 }, Const { destination: Direct(32845), bit_size: Integer(U8), value: 101 }, Const { destination: Direct(32846), bit_size: Integer(U8), value: 103 }, Const { destination: Direct(32847), bit_size: Integer(U8), value: 104 }, Const { destination: Direct(32848), bit_size: Integer(U8), value: 105 }, Const { destination: Direct(32849), bit_size: Integer(U8), value: 107 }, Const { destination: Direct(32850), bit_size: Integer(U8), value: 110 }, Const { destination: Direct(32851), bit_size: Integer(U8), value: 114 }, Const { destination: Direct(32852), bit_size: Integer(U8), value: 115 }, Const { destination: Direct(32853), bit_size: Integer(U8), value: 116 }, Const { destination: Direct(32854), bit_size: Integer(U8), value: 123 }, Const { destination: Direct(32855), bit_size: Integer(U8), value: 125 }, Return, Call { location: 175 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 181 }, Mov { destination: Direct(0), source: Relative(0) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 46 }, Call { location: 392 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 395 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 38 }, 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(32854) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32849) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, 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: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32852) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32840) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32847) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32842) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 395 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 149 }, Call { location: 442 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 157 }, Call { location: 445 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 395 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 170 }, Call { location: 442 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 180 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, Const { destination: Relative(6), bit_size: Field, value: 11 }, JumpIf { condition: Relative(3), location: 225 }, Jump { location: 188 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(7), location: 221 }, Jump { location: 191 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Relative(9), source: Relative(8) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Direct(32835), rhs: Direct(32837) }, JumpIf { condition: Relative(8), location: 219 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, Mov { destination: Relative(11), source: Relative(10) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(12) }, Mov { destination: Direct(32772), source: Relative(11) }, Mov { destination: Direct(32773), source: Relative(13) }, Call { location: 448 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(10), size: Relative(9) } }, Mov { destination: Relative(3), source: Relative(6) }, Jump { location: 223 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 223 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 227 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 227 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 108 }, JumpIf { condition: Relative(1), location: 317 }, Jump { location: 231 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 239 }, Jump { location: 234 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 238 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 391 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Relative(6), source: Relative(5) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Direct(32845) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32842) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(2), size: 3 }), HeapArray(HeapArray { pointer: Relative(3), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 391 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(4), source: Direct(32847) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Direct(32848) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(4) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32841) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(3), size: 2 }), HeapArray(HeapArray { pointer: Relative(4), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 391 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 411 }, Jump { location: 402 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 413 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 413 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 438 }, Jump { location: 416 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 430 }, Jump { location: 419 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 423 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 428 }, Call { location: 445 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 436 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 434 }, Call { location: 445 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 436 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 440 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 440 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 458 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 451 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32857 }, 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(32856), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32856) }, Call { location: 13 }, Call { location: 35 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32857 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U1), 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(U8), value: 34 }, Const { destination: Direct(32840), bit_size: Integer(U8), value: 44 }, Const { destination: Direct(32841), bit_size: Integer(U8), value: 50 }, Const { destination: Direct(32842), bit_size: Integer(U8), value: 51 }, Const { destination: Direct(32843), bit_size: Integer(U8), value: 58 }, Const { destination: Direct(32844), bit_size: Integer(U8), value: 100 }, Const { destination: Direct(32845), bit_size: Integer(U8), value: 101 }, Const { destination: Direct(32846), bit_size: Integer(U8), value: 103 }, Const { destination: Direct(32847), bit_size: Integer(U8), value: 104 }, Const { destination: Direct(32848), bit_size: Integer(U8), value: 105 }, Const { destination: Direct(32849), bit_size: Integer(U8), value: 107 }, Const { destination: Direct(32850), bit_size: Integer(U8), value: 110 }, Const { destination: Direct(32851), bit_size: Integer(U8), value: 114 }, Const { destination: Direct(32852), bit_size: Integer(U8), value: 115 }, Const { destination: Direct(32853), bit_size: Integer(U8), value: 116 }, Const { destination: Direct(32854), bit_size: Integer(U8), value: 123 }, Const { destination: Direct(32855), bit_size: Integer(U8), value: 125 }, Return, Call { location: 175 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 181 }, Mov { destination: Direct(0), source: Relative(0) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 46 }, Call { location: 392 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 395 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 38 }, 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(32854) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32849) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, 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: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32852) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32840) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32847) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32842) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 395 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 149 }, Call { location: 442 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 157 }, Call { location: 445 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 395 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 170 }, Call { location: 442 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 180 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, JumpIf { condition: Relative(3), location: 224 }, Jump { location: 187 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 220 }, Jump { location: 190 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Direct(32835), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 218 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(9), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, Mov { destination: Relative(10), source: Relative(9) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(11) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(12) }, Call { location: 448 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(9), size: Relative(8) } }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 222 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 222 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 226 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 226 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 108 }, JumpIf { condition: Relative(1), location: 317 }, Jump { location: 230 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 239 }, Jump { location: 233 }, Const { destination: Relative(1), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 238 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 391 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Relative(6), source: Relative(5) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Direct(32845) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32842) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(2), size: 3 }), HeapArray(HeapArray { pointer: Relative(3), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 391 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(4), source: Direct(32847) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Direct(32848) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(4) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32841) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(3), size: 2 }), HeapArray(HeapArray { pointer: Relative(4), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 391 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 411 }, Jump { location: 402 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 413 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 413 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 438 }, Jump { location: 416 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 430 }, Jump { location: 419 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 423 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 428 }, Call { location: 445 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 436 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 434 }, Call { location: 445 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 436 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 440 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 440 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 458 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 451 }, Return]" ], - "debug_symbols": "tdjNThtLEEDhd/GaxfRvVfMqURQ5YCJLlkEOXOkK8e63y1XHFxZGyBab1CGkP9vjnvHEr6v7ze+XP7+2+4fHv6vbH6+r34ftbrf982v3eLd+3j7u59++rhb7o/TVbbpZFfGhPsZx1MVH8pFXt3mO4qP6aD6mUuYQH+pjHEdbfCQf2cdU+hzVR/PRfYgP9TGOoy8+ko/sw5XuSnelu9Jd6a50V8QVcUVcEVfEFXFFXBFXxBVxRV1RV9QVdUVdUVfUFXVFXVFXhivDleHKcGW4MlwZrgxXhivDlbQsMVPMHLPErDFbzB5TYmrM8FJ4KbwUXgovhZfCS+Gl8FJ4KbwcXg4vh5fDy+Hl8HJ4ObwcXg6vhFfCK+GV8Mr0xGaLOT21KTE15vBpm/w4U8wcc3opWVSiEZ0QQokRYbvew86ebJEJk4tFJRrRCZOrhRIjws4Ej0RkohAm26u3c8KjE0IoMSLs7PBIhMl2NOwcOYbt9jQs5vK8zLAN7JGJQlSiEZ0Q4uTMp5Hn8cm2oz0SkYlCVKIRnRBCCeSEnJATckJOyAk5ISfkhGybNM/3K9tu9KhEIzpx+sf2fObblG3veSQiE4WoRCM6IYQSyA25Idv2y2JRiEo0ohNCKDEibPt5JAK5I3fkjtyRO3JH7siCLMiCLMiCLMiCLMiCLMiKrMiKrMiKrMiKrMiKrMgDeSAP5IE8kAfyQB7IA3mEXJaFSEQmClGJRnRCCCWQE3JCTsjHs0AtKtEIA4eFEiPCLvEeichEISrRCLtnyBZCKDEi7GLvkYhMFKISjUAuyAW5IFfkilyRK3JFrsgVuSJX5IrckBtyQ27IDbkhN+SG3JAbckfuyB25I3fkjtyRO3JH7siCLMiCLMiCLMiCLMiCLMiKrMiKrMiKrMiKbKdeKRZKjAg7iUq1u1QDm0WJsG1cukUnRoTtVY9EZMJWiUUlGtEJiTjuTLVIRCbM0be3mxW327+eD5uN3W2/u/+ed+VP68Nm/7y63b/sdjerf9a7l+M/+vu03h/n8/owfzs/Gzf7+zkn+LDdbazebv5fvZxfap9Rx7U1nxa3L68eJVYPvWB166weF6yuGqvn/e255fX8ch2JR8/ltD7nD+vb962XKrFedDm3/pOXn+wuzl9/KxccvnmXf1pfz60fV77+tHwjcO0RnDeGsX7e9V1yBLue1qeL1i+n9WdPvnTtFkz9G4Fr34L5UR/r58f3BYdwfvCxvrdLriELb0E9/xbm9MkB4PIpclpey5cfPpfT1befffhy1cN/tnzed3L4lrMX8HztDsz9G4Ev7cBPD+G1wPw/DaexnH0Ty7UXwpK+Ebj2NO4Lp2FPl5yGvXIIe73kVqAPrsSynL2Slk92UVOeQBuXAZVP09Y+HoGf86f13fbw4YvVN5MO2/Xv3SZ+fHjZ37377fO/T/yGL2afDo93m/uXw8akd9/OzvvEOu+FatOf9h3d/DFJu0m62I/zzvNHGfmmjPrzzZ7Mfw==", + "debug_symbols": "tdjNThtLEEDhd/GaxfRvVfMqURQ5YCJLlkEOXOkK8e63y1XHFxZGyBab1CGkP9vjnvHEr6v7ze+XP7+2+4fHv6vbH6+r34ftbrf982v3eLd+3j7u59++rhb7o/TVbbpZFfGhPsZx1MVH8pFXt3mO4qP6aD6mUuYQH+pjHEdbfCQf2cdU+hzVR/PRfYgP9TGOoy8+ko/sw5XuSnelu9Jd6a50V8QVcUVcEVfEFXFFXBFXxBVxRV1RV9QVdUVdUVfUFXVFXVFXhivDleHKcGW4MlwZrgxXhivDlbQsMVPMHLPErDFbzB5TYmrM8FJ4KbwUXgovhZfCS+Gl8FJ4KbwcXg4vh5fDy+Hl8HJ4ObwcXg6vhFfCK+GV8Mr0xGaLOT21KTE15vBpm/w4U8wcc3opWVSiEZ0QQokRYbvew86ebJEJk4tFJRrRCZOrhRIjws4Ej0RkohAm26u3c8KjE0IoMSLs7PBIhMl2NOwcOYbt9jQsppOXGbaPPRKRiUJUohGdODnz+WQ7PrazLbJtbY9EZKIQlWhEJ4RQAjkhJ+SEnJATckJOyAnZNmue71e2XelRiEo04vSPhbDnM9+vbJvQIxGZKEQlGtEJIZRAbsgN2fZhFotCVKIRnRBCiRFh+9AjEcgduSN35I7ckTtyRxZkQRZkQRZkQRZkQRZkQVZkRVZkRVZkRVZkRVZkRR7IA3kgD+SBPJAH8kAeyCPksixEIjJRiEo0ohNCKIGckBNyQj6eBWpRiUYYOCyUGBF2rfdIRCYKUYlG2M1DthBCiRFh55dHIjJRiEo0ArkgF+SCXJErckWuyBW5IlfkilyRK3JDbsgNuSE35IbckBtyQ27IHbkjd+SO3JE7ckfuyB25IwuyIAuyIAuyIAuyIAuyICuyIiuyIiuyIiuynXqlWCgxIuwkKtVuVw1sFiXCtnHpFp0YEbZXPRKRCVslFpVoRCck4rgz1SIRmTBH395uVtx3/3o+bDZ22/3uRnzenj+tD5v98+p2/7Lb3az+We9ejv/o79N6f5zP68P87fyQ3Ozv55zgw3a3sXq7+X/1cn6pfVgd19Z8Wty+vHqUWD30gtWts3pcsLpqrJ43uueW1/PLdSQePZfT+pw/rG/ft16qxHrR5dz6T15+sts5f/2tXHD45u3+aX09t35c+frT8o3AtUdw3hjG+nnXd8kR7Hpany5av5zWnz350rVbMPVvBK59C+ZHfayfH98XHML5wcf63i65hiy8BfX8W5jTJweAy6fIaXktX374XE5X33724ctVD//Z8nnfyeFbzl7A87U7MPdvBL60Az89hNcC8/80nMZy9k0s114IS/pG4NrTuC+chj1dchr2yiHs9ZJbgT64Esty9kpaPtlFTXkCbVwGVD5NW/t4BH7On9Z328OHb1jfTDps1793m/jx4WV/9+63z/8+8Ru+oX06PN5t7l8OG5PefU077xPrvBeqTX/al3XzxyTtJuliP847zx9l5Jsy6s83ezL/AQ==", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap index 96d062dbb2a..019e62ec4fd 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap @@ -50,9 +50,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32837) }, Call { location: 13 }, Call { location: 16 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 378 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, Const { destination: Relative(6), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 11 }, JumpIf { condition: Relative(3), location: 62 }, Jump { location: 25 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(9), location: 58 }, Jump { location: 28 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(9) }, Const { destination: Relative(9), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(7) }, JumpIf { condition: Relative(11), location: 56 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(13), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, Mov { destination: Relative(14), source: Relative(13) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(15) }, Mov { destination: Direct(32772), source: Relative(14) }, Mov { destination: Direct(32773), source: Relative(16) }, Call { location: 384 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(9) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(13), size: Relative(12) } }, Mov { destination: Relative(3), source: Relative(8) }, Jump { location: 60 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 60 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 64 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 64 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(3), location: 171 }, Jump { location: 85 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 93 }, Jump { location: 88 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(3), location: 92 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Jump { location: 245 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(8) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(22) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(12) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(15) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(16) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(17) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(18) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(19) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(20) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(21) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(22) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(19) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(17) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(4) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(15) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(25) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(24) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(3), size: 3 }), HeapArray(HeapArray { pointer: Relative(8), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(4) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(9) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(8), source: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(12) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(15) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(16) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(17) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(18) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(19) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(20) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(21) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(22) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(13) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(19) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(17) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(4) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(15) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(23) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(24) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(5), size: 2 }), HeapArray(HeapArray { pointer: Relative(8), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32836), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 249 }, Call { location: 395 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 26 }, Mov { destination: Relative(26), source: Direct(0) }, Mov { destination: Relative(27), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(27) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(21) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(9) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(15) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(9) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(19) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(9) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(17) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(19) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(20) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(5) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(9) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(17) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(4) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(15) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(25) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(23) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 352 }, Call { location: 445 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 360 }, Call { location: 448 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(10) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 373 }, Call { location: 445 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 383 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 394 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 387 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 378 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 414 }, Jump { location: 405 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 416 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 416 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 441 }, Jump { location: 419 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 433 }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 426 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 431 }, Call { location: 448 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 439 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 437 }, Call { location: 448 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 439 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 443 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 443 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32837) }, Call { location: 13 }, Call { location: 16 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 378 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, Const { destination: Relative(6), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(3), location: 61 }, Jump { location: 24 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 57 }, Jump { location: 27 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(9), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(9), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Mov { destination: Relative(11), source: Relative(10) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(7) }, JumpIf { condition: Relative(10), location: 55 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, Mov { destination: Relative(13), source: Relative(12) }, IndirectConst { destination_pointer: Relative(13), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(14) }, Mov { destination: Direct(32772), source: Relative(13) }, Mov { destination: Direct(32773), source: Relative(15) }, Call { location: 384 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(8) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(12), size: Relative(11) } }, Mov { destination: Relative(3), source: Relative(8) }, Jump { location: 59 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 59 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 63 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 63 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(3), location: 171 }, Jump { location: 84 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 93 }, Jump { location: 87 }, Const { destination: Relative(3), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 92 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Jump { location: 245 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(25) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(25) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(25), source: Relative(3) }, Store { destination_pointer: Relative(25), source: Relative(9) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(11) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(13) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(15) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(19) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(20) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(21) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(4) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(24) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(23) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(3), size: 3 }), HeapArray(HeapArray { pointer: Relative(20), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(4) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(25), source: Relative(5) }, Store { destination_pointer: Relative(25), source: Relative(9) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(11) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(13) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(15) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(19) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(20) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(21) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(4) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(23) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(5), size: 2 }), HeapArray(HeapArray { pointer: Relative(20), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32836), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 249 }, Call { location: 395 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 25 }, Mov { destination: Relative(25), source: Direct(0) }, Mov { destination: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(26) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(25) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(25) }, Store { destination_pointer: Relative(26), source: Relative(9) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(15) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(17) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(19) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(5) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(4) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(23) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 21 }, Mov { destination: Relative(21), source: Direct(0) }, Mov { destination: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(22) }, Load { destination: Relative(3), source_pointer: Relative(20) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 352 }, Call { location: 445 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 360 }, Call { location: 448 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 21 }, Mov { destination: Relative(21), source: Direct(0) }, Mov { destination: Relative(22), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(22) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 373 }, Call { location: 445 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 383 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 394 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 387 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 378 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 414 }, Jump { location: 405 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 416 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 416 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 441 }, Jump { location: 419 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 433 }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 426 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 431 }, Call { location: 448 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 439 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 437 }, Call { location: 448 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 439 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 443 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 443 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tdjNThtZEEDhd+m1F11V95dXiRAyYCJLlkEOjDRCvHtu9b2HhEWjyJY3U8fj1GdounHj9+lxd//2825/fHr+Nd38eJ/uT/vDYf/z7vD8sH3dPx/b/32fZv+P5OlGN5PG6cbaKH3UZdjch/ShfVgfoY++Z2m6iW3kPkofdRlh7kP60D6sj9BH7KMroSuhK6ErsSuxK7ErsSuxK7ErqT1Km6nEPkofdRl17kP6aOu5jdBH7CP1kfsofdRlyDyPKWPqmDZmGDOO2TCZPTJRiDpCZkIIJYwIRCSQBVmQBVmRFVmRFVmRFVmRFVmRFdmQDdmQDdmQDdmQDdmQDTkgB+SAHJADckAOyAE5IAfkiByRI3JEjsgROSJH5IgckRNyQk7ICTkhJ+SEnFwWj0LUEdlB9VDCiEBEIhGZKEQdUfxLjR5CKGFEICKRiEwUoo6oyBW5IlfkilyRK3JFrsh1yDrPhBBKGBGISCQiE4VAFmRBFmRBFmRBFmRBFmRBVmRFVmRFVmRFVmRFVmRFNmRDNmRDNmRDNmRDNmRDDsjLpZc8lDDCweyRiEwUwsHi7ykzIYQSRgQiEk1W8chEIeoIv+J6CKGEEYGIBHJCTsgJOSNn5IyckTNyRs7IGTkjZ+SCXJALckEuyAW5IBfkglyQK3JFrsgVuSJX5IpckStyHbLNMyGEEkYEIhKJyEQhkAVZkAVZkAVZkAVZkAVZkBVZkRVZkRVZkRVZkRVZkQ3ZkA3ZkA3ZkA3ZLz1Vj0K4vNxMzYQQShgRiEi4nDwyUYg6wq/BHkIoYYTL2SMSLhePTBSijliuweohhBJGBCISiWiy+UHwa7BHHeHXYA8hlDAiEH4H6kfDr8El/Oy14Dee/tRyB5pG+PljyaOO8HOjhxGBiIRvZY9MFKKOWO6Vl3CneAQiEu6Uj4/NxH343etpt/Pb8L9uzNvt+sv2tDu+TjfHt8NhM/23Pbwt/+jXy/a4zNftqT3b7h12x8c2G/i0P+y8PjZ/tuf1VT/7lt2gn8vx67asb7erZqy3K+Gc/VjZT/GM/TDzrQdZff2wvp/57nP+3A72z6/u1944eGnt1dNFr/7NdvtFzrGby9qrl/X9UmXsV7XPfdUv+/V6+zlkvv0yr+2n6+23+4Ox3960V889u/AASLgi8E+H4JuLv3IE6uoJ9M12TGzXM7ZDGdvtT+nVo3/p6afzFYFLj74IF3D7s/OMI9g+U/jcD2v7eun557/hrwZcegjbH3lcwzKfcwhT+dyXs/bnz/3V90+79CQ0uSJw6Y8gzbyFJ4lnHMIU+CWUwjm/R1LlR5jn9R/BN+8DsfAFxHoeELgOY/x6BG7bo+3D/vTl09YPl0777f1hNx4+vR0f/nr29f8XnuHT2pfT88Pu8e20c+nPR7btBvOHlbCxGm79g0R/mMvGivlD8Yc1tmfz7Yd/Mb8B", + "debug_symbols": "tdjNThtZEEDhd+m1F11V95dXiRAyYCJLlkEOjDRCvHtu9b2HhEWjyJY3U8fj1GdounHj9+lxd//2825/fHr+Nd38eJ/uT/vDYf/z7vD8sH3dPx/b/32fZv+P5OlGN5OG6cbayH2UPuoybO5D+tA+rI++Z3G6iW2kPnIfpY+6jDD3IX1oH9ZH6KMroSuhK6EroSuxK7ErsSuxK7ErqT1Km6mEPnIfpY+6jDr3IX20hdxG6CP2kfrIfZQ+6jJknseUMXVMGzOMGcdsmMwemShEHSEzIYQSRgQiEsiCLMiCrMiKrMiKrMiKrMiKrMiKbMiGbMiGbMiGbMiGbMiGHJADckAOyAE5IAfkgByQA3JEjsgROSJH5IgckSNyRI7ICTkhJ+SEnJATckJOLotHIeqI7KB6KGFEICKRiEwUoo4o/qVGDyGUMCIQkUhEJgpRR1TkilyRK3JFrsgVuSJX5DpknWdCCCWMCEQkEpGJQiALsiALsiALsiALsiALsiArsiIrsiIrsiIrsiIrsiIbsiEbsiEbsiEbsiEbsiEH5OXSSx5KGOFg9khEJgrhYGmxXHFLCKGEEYGIRJNVPDJRiDrCr7geQihhRCAigZyQE3JCzsgZOSNn5IyckTNyRs7IGbkgF+SCXJALckEuyAW5IBfkilyRK3JFrsgVuSJX5Ipch2zzTAihhBGBiEQiMlEIZEEWZEEWZEEWZEEWZEEWZEVWZEVWZEVWZEVWZEVWZEM2ZEM2ZEM2ZEP2S0/VoxAuLzdTMyGEEkYEIhIuJ49MFKKO8GuwhxBKGOFy9oiEy8UjE4WoI5ZrsHoIoYQRgYhEIvyO0w+CX4M96gi/BnsIoYQRgWiy+dHwa3AJP3st+I2nP7XcgaYRfv5Y8qgj/NzoYUQgIuFb2SMThagjlnvlJdwpHoGIhDvl42MzcTt+93ra7fxu/K/783bX/rI97Y6v083x7XDYTP9tD2/LP/r1sj0u83V7as+2e4fd8bHNBj7tDzuvj82f7Xl91c++ZTfo53L8ui3r2+2qGevtSjhnP1b2UzxjP8x860FWXz+s72e++5w/t4P986v7tTcOXlp79XTRq3+z3X6Rc+zmsvbqZX2/VBn7Ve1zX/XLfr3efg6Zb7/Ma/vpevvt/mDstzft1XPPLjwAEq4I/NMh+ObirxyBunoCfbMdE9v1jO1Qxnb7U3r16F96+ul8ReDSoy/CBdz+7DzjCLbPFD73w9q+Xnr++W/4qwGXHsL2Rx7XsMznHMJUPvflrP35c3/1/dMuPQlNrghc+iNIM2/hSeIZhzAFfgmlcM7vkVT5EeZ5/UfwzftALHwBsZ4HBK7DGL8egdv2aPuwP3350PXDpdN+e3/YjYdPb8eHv559/f+FZ/jQ9uX0/LB7fDvtXPrzyW27wfxhJWyshlv/INEf5rKxYv5Q/GGN7dl8++FfzG8=", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 964817b1bd3..8985f326da4 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -50,9 +50,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 479 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, Const { destination: Relative(7), bit_size: Field, value: 8 }, Const { destination: Relative(8), bit_size: Field, value: 9 }, Const { destination: Relative(9), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(11), bit_size: Field, value: 11 }, JumpIf { condition: Relative(4), location: 62 }, Jump { location: 26 }, JumpIf { condition: Relative(6), location: 58 }, Jump { location: 28 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(14), source: Direct(1) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(15) }, IndirectConst { destination_pointer: Relative(14), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Mov { destination: Relative(16), source: Relative(15) }, Store { destination_pointer: Relative(16), source: Relative(13) }, Const { destination: Relative(13), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(10) }, JumpIf { condition: Relative(15), location: 56 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(17), source: Direct(1) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(18) }, Mov { destination: Relative(18), source: Relative(17) }, IndirectConst { destination_pointer: Relative(18), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(19) }, Mov { destination: Direct(32772), source: Relative(18) }, Mov { destination: Direct(32773), source: Relative(20) }, Call { location: 485 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(13) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(17), size: Relative(16) } }, Mov { destination: Relative(12), source: Relative(11) }, Jump { location: 60 }, Mov { destination: Relative(12), source: Relative(8) }, Jump { location: 60 }, Mov { destination: Relative(2), source: Relative(12) }, Jump { location: 64 }, Mov { destination: Relative(2), source: Relative(7) }, Jump { location: 64 }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(2), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(26), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(28), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(29), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(12), location: 171 }, Jump { location: 85 }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(12), location: 93 }, Jump { location: 88 }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Relative(11) }, JumpIf { condition: Relative(8), location: 92 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Jump { location: 245 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(30), source: Relative(12) }, Store { destination_pointer: Relative(30), source: Relative(2) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(8) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(26) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(12), source: Relative(14) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(16) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(13) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(17) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(18) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(20) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(21) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(22) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(13) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(17) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(23) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(24) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(25) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(26) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(17) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(23) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(21) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(7) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(29) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(28) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(8), size: 3 }), HeapArray(HeapArray { pointer: Relative(12), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(13) }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(14) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(16) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(13) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(17) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(18) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(20) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(21) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(22) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(13) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(17) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(23) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(24) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(25) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(26) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(17) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(23) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(21) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(7) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(15) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(27) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(28) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(11), size: 2 }), HeapArray(HeapArray { pointer: Relative(12), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 249 }, Call { location: 496 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Const { destination: Relative(12), bit_size: Field, value: 4 }, Const { destination: Relative(25), bit_size: Field, value: 5 }, Const { destination: Relative(30), bit_size: Field, value: 6 }, JumpIf { condition: Relative(11), location: 264 }, Jump { location: 255 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(31), source: Relative(11), bit_size: U1 }, Cast { destination: Relative(32), source: Relative(11), bit_size: Field }, Cast { destination: Relative(11), source: Relative(31), bit_size: Field }, BinaryFieldOp { destination: Relative(31), op: Mul, lhs: Relative(32), rhs: Relative(25) }, BinaryFieldOp { destination: Relative(32), op: Mul, lhs: Relative(11), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(31), rhs: Relative(32) }, Mov { destination: Relative(2), source: Relative(11) }, Jump { location: 266 }, Mov { destination: Relative(2), source: Relative(12) }, Jump { location: 266 }, BinaryFieldOp { destination: Relative(31), op: Equals, lhs: Relative(2), rhs: Relative(12) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(31), location: 291 }, Jump { location: 270 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(25) }, JumpIf { condition: Relative(33), location: 283 }, Jump { location: 273 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(33), location: 277 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(32) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 281 }, Call { location: 499 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 289 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 287 }, Call { location: 499 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 289 }, Mov { destination: Relative(11), source: Relative(31) }, Jump { location: 293 }, Mov { destination: Relative(11), source: Relative(8) }, Jump { location: 293 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(31), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(33), source: Direct(1) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(34) }, IndirectConst { destination_pointer: Relative(33), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, Mov { destination: Relative(35), source: Relative(34) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(15) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(13) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(15) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(19) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(15) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(8) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(20) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(13) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(23) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(26) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(13) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(21) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(26) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(23) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(26) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(22) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(15) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(24) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(15) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(31) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(13) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(21) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(7) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(15) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(19) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(29) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(27) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(28) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(11)), HeapArray(HeapArray { pointer: Relative(7), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, JumpIf { condition: Relative(4), location: 386 }, Jump { location: 378 }, Not { destination: Relative(4), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(7), source: Relative(6), bit_size: Field }, Cast { destination: Relative(6), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Mul, lhs: Relative(7), rhs: Relative(25) }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(6), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(6), op: Add, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(6) }, Jump { location: 388 }, Mov { destination: Relative(2), source: Relative(12) }, Jump { location: 388 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(12) }, JumpIf { condition: Relative(6), location: 412 }, Jump { location: 391 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(25) }, JumpIf { condition: Relative(7), location: 404 }, Jump { location: 394 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(7), location: 398 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(32) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 402 }, Call { location: 499 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 410 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 408 }, Call { location: 499 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 410 }, Mov { destination: Relative(4), source: Relative(6) }, Jump { location: 414 }, Mov { destination: Relative(4), source: Relative(1) }, Jump { location: 414 }, Load { destination: Relative(6), source_pointer: Relative(33) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 420 }, Call { location: 502 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(4)), HeapArray(HeapArray { pointer: Relative(6), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 428 }, Call { location: 499 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(1), location: 440 }, Jump { location: 431 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Not { destination: Relative(3), source: Relative(1), bit_size: U1 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Cast { destination: Relative(1), source: Relative(3), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(6), rhs: Relative(25) }, BinaryFieldOp { destination: Relative(6), op: Mul, lhs: Relative(1), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Add, lhs: Relative(3), rhs: Relative(6) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 442 }, Mov { destination: Relative(2), source: Relative(12) }, Jump { location: 442 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 466 }, Jump { location: 445 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(25) }, JumpIf { condition: Relative(6), location: 458 }, Jump { location: 448 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(5), location: 452 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(32) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 456 }, Call { location: 499 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 464 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 462 }, Call { location: 499 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 464 }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 468 }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 468 }, Load { destination: Relative(2), source_pointer: Relative(33) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 474 }, Call { location: 502 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 484 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 495 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 488 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 479 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, Const { destination: Relative(7), bit_size: Field, value: 8 }, Const { destination: Relative(8), bit_size: Field, value: 9 }, Const { destination: Relative(9), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 61 }, Jump { location: 25 }, JumpIf { condition: Relative(6), location: 57 }, Jump { location: 27 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(13), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(13), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 55 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(16), source: Direct(1) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(17) }, Mov { destination: Relative(17), source: Relative(16) }, IndirectConst { destination_pointer: Relative(17), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(18) }, Mov { destination: Direct(32772), source: Relative(17) }, Mov { destination: Direct(32773), source: Relative(19) }, Call { location: 485 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(12) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(16), size: Relative(15) } }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 59 }, Mov { destination: Relative(11), source: Relative(8) }, Jump { location: 59 }, Mov { destination: Relative(2), source: Relative(11) }, Jump { location: 63 }, Mov { destination: Relative(2), source: Relative(7) }, Jump { location: 63 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(26), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(28), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(11), location: 171 }, Jump { location: 84 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 93 }, Jump { location: 87 }, Const { destination: Relative(8), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 92 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 245 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(29) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(30), source: Relative(29) }, Store { destination_pointer: Relative(30), source: Relative(2) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(8) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(25) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(29), source: Relative(8) }, Store { destination_pointer: Relative(29), source: Relative(13) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(15) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(17) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(19) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(21) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(23) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(25) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(7) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(27) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(8), size: 3 }), HeapArray(HeapArray { pointer: Relative(24), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Relative(29), source: Relative(11) }, Store { destination_pointer: Relative(29), source: Relative(13) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(15) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(17) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(19) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(21) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(23) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(25) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(7) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(26) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(27) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(11), size: 2 }), HeapArray(HeapArray { pointer: Relative(24), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 249 }, Call { location: 496 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Const { destination: Relative(24), bit_size: Field, value: 4 }, Const { destination: Relative(29), bit_size: Field, value: 5 }, Const { destination: Relative(30), bit_size: Field, value: 6 }, JumpIf { condition: Relative(11), location: 264 }, Jump { location: 255 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(31), source: Relative(11), bit_size: U1 }, Cast { destination: Relative(32), source: Relative(11), bit_size: Field }, Cast { destination: Relative(11), source: Relative(31), bit_size: Field }, BinaryFieldOp { destination: Relative(31), op: Mul, lhs: Relative(32), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(32), op: Mul, lhs: Relative(11), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(31), rhs: Relative(32) }, Mov { destination: Relative(2), source: Relative(11) }, Jump { location: 266 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 266 }, BinaryFieldOp { destination: Relative(31), op: Equals, lhs: Relative(2), rhs: Relative(24) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(31), location: 291 }, Jump { location: 270 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(33), location: 283 }, Jump { location: 273 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(33), location: 277 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(32) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 281 }, Call { location: 499 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 289 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 287 }, Call { location: 499 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 289 }, Mov { destination: Relative(11), source: Relative(31) }, Jump { location: 293 }, Mov { destination: Relative(11), source: Relative(8) }, Jump { location: 293 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(31), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(33), source: Direct(1) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(34) }, IndirectConst { destination_pointer: Relative(33), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, Mov { destination: Relative(35), source: Relative(34) }, Store { destination_pointer: Relative(35), source: Relative(13) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(15) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(8) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(19) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(22) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(20) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(22) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(21) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(23) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(31) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(20) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(7) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(28) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(26) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(27) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(11)), HeapArray(HeapArray { pointer: Relative(7), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, JumpIf { condition: Relative(4), location: 386 }, Jump { location: 378 }, Not { destination: Relative(4), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(7), source: Relative(6), bit_size: Field }, Cast { destination: Relative(6), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Mul, lhs: Relative(7), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(6), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(6), op: Add, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(6) }, Jump { location: 388 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 388 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(24) }, JumpIf { condition: Relative(6), location: 412 }, Jump { location: 391 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(7), location: 404 }, Jump { location: 394 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(7), location: 398 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(32) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 402 }, Call { location: 499 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 410 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 408 }, Call { location: 499 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 410 }, Mov { destination: Relative(4), source: Relative(6) }, Jump { location: 414 }, Mov { destination: Relative(4), source: Relative(1) }, Jump { location: 414 }, Load { destination: Relative(6), source_pointer: Relative(33) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 420 }, Call { location: 502 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(4)), HeapArray(HeapArray { pointer: Relative(6), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 428 }, Call { location: 499 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(1), location: 440 }, Jump { location: 431 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Not { destination: Relative(3), source: Relative(1), bit_size: U1 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Cast { destination: Relative(1), source: Relative(3), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(6), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(6), op: Mul, lhs: Relative(1), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Add, lhs: Relative(3), rhs: Relative(6) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 442 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 442 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(24) }, JumpIf { condition: Relative(3), location: 466 }, Jump { location: 445 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(6), location: 458 }, Jump { location: 448 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(5), location: 452 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(32) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 456 }, Call { location: 499 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 464 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 462 }, Call { location: 499 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 464 }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 468 }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 468 }, Load { destination: Relative(2), source_pointer: Relative(33) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 474 }, Call { location: 502 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 484 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 495 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 488 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tZnbbtpMFEbfhWsuPPswh7xKVVU0pRUSIhFNfulXlXfvbI8XbS+MIlBu+i0X9rI9sz1M4Nfm2/7r648vh9P3p5+bh0+/Nl/Ph+Px8OPL8elx93J4OvX//bWZ4p/kmwfZblIeUTYP1qPOIT28R5tDpxFphIzQETbCR3RZ6VFG1BFtDptGpBEyQkfYCB8xLDYsNiw2LD4sPiw+LD4sPiw+LLkf1e2m+og6os3RphFpRC9vPWyEj8gjyog6os2RpmnJtKQsqUvakr5kl6UY5akAFWgLpAlIgAAKGOAA5oQ5YU6YBbNgFsyCWTALZsEsmAWzYFbMilkxK2bFrJgVs2JWzIrZMBtmw2yYDbNhNsyG2TAbZsfsmB2zY3bMjtkxO2bH7Jgz5ow5Y86YM+aMOWPOYdaACrQFSgjj8SwCKGCAAxkoQAXaAjUutQQkQAAFDHAgAwWoQFugYW6YG+aGuWFumBvmhrlhbotZpglIgAAKGOBABgpQAcwJc8KcMCfMCXPCnDAnzAlzwiyYBbNgFsyCWTALZsEsmAWzYlbMilkxK2bFrJgVs2JWzIZ5fvRqgAAKhLAFZKAAFehCSR3iIRIJyAtEz0tvbCkToIABDlze3E8h8ekU/TygLRD9PCA88dEV3TvAgbxA9KHEXUQfDnAgAwWoQBug0YcDEiCAAgY4kIECVABzwpwwJ8wJc8KcMCfMCXPCnDALZsEsmAWzYBbMglkwC2bBrJgVs2JWzIpZMStmxayYFbNhNsyG2TAbZsNsmA2zYTbMjtkxO2bH7Jgds2N2zI7ZMWfMGXPGnDFnzBlzxpwxZ8wZc8FcMBfMBfP87LQAB8Z+TmOd1in2YgkwwIEMFCCqUkAbYNH7AxIQHglwIANlgehZ9QAHMlCACrQFomcHJKDfseYABcI8bycdyEABwtxir9k9NgXIAtFQFncR7TOgAm2BaJYBCYiquK9olgEGOBAeDWgLRGsMSEC8J+4iJnmGmOQBCRBAAQMc6Lds84Y5NvHl7W27Ybv/5eW838du/6/9f/+r4Hl33p9eNg+n1+Nxu/lvd3yd3/TzeXea82V37q/2EdqfvvXswu+H4z7obfunelovjVV+rjW5FPu/1Wm9WmOZnsv7qrJWf+XsKfY4c33f0q3V63p9jumZ67O1W67fG9ef/Yb6/pgxfGn1/vN6fWH0S7lUm7777KKXyctrZ693nf1Kdf9QZuymujp2Vya/trQImvyZfJF/BekDBSUexjECdVoT1I+rl8wE9r3T6hD6vSOQP1DwriG40gSNEWj1hvXDM9WrT79cKc8Tj39OfpPgPevPVUGrDN+0ugDLlRXQK1fg7TaBMYbufsMUGDfQv2tZPf+9HSjlAwXvamG9cw51unMOrwrunMP+tdflY9hWL0DvnAO1DxTcuw717yFYitN0yxDmeqlf3QlovXMtuip4z1p0VfCePrZ0Zx9fFdzbx3m6TML6BdzbhuYfKFjv48/9aPd4OP/zC8FbmM6H3dfjfjn8/np6/OvVl/+feYVfGJ7PT4/7b6/nfZj+/MzQ/2z5ZNW31vxzfN0dh6VtrVocpjhsub9aP7/FxfwG", + "debug_symbols": "tdnLbhpJFIDhd2HNoutc6uJXiaKIOCRCQtgi9kijyO+eOl39k2TRyAJ5M+dnnPqA7qLdtn9tvu2/vv74cjh9f/q5efj0a/P1fDgeDz++HJ8edy+Hp1P/v782U/wn+eZBtpuUxyibB+ujzkP6I++jjtHmodMYaQwZQ8ewMbpZ+shjlDHqGG0eNo2RxpAxdAwbYyg2FBuKDcWG4kPxofhQfCg+lNwf1e2m2hhljDpGm0ebxkhj9AWtDxvDx8hjlDHqGG0eaZqWmZYpy9Rl2jJ9mR1LcbCnQlSiLZEmIhFCKGGEE8gJOSEnZEEWZEEWZEEWZEEWZEEWZEVWZEVWZEVWZEVWZEVWZEM2ZEM2ZEM2ZEM2ZEM2ZEd2ZEd2ZEd2ZEd2ZEd25IyckTNyRs7IGTkj55A1ohJtiRJgfEqLEEoY4UQmClGJtkSNl1oiEiGEEkY4kYlCVKIt0ZAbckNuyA25ITfkhtyQ2yLLNBGJEEIJI5zIRCEqgZyQE3JCTsgJOSEn5ISckBOyIAuyIAuyIAuyIAuyIAuyIiuyIiuyIiuyIiuyIiuyIc8fvRohhBIBtohMFKISHZTUIz5EIhF5idjzovHtZiKUMMKJyz/uTyHzN6lKtCViP48IZ/4OZoQTeYnYhxLvIvbhCCcyUYhKtBEa+3BEIoRQwggnMlGISiAn5ISckBNyQk7ICTkhJ+SELMiCLMiCLMiCLMiCLMiCrMiKrMiKrMiKrMiKrMiKbMiGbMiGbMiGbMiGbMiG7MiO7MiO7MiO7MiO7MiOnJEzckbOyBk5I2fkjJyRM3JBLsgFuSDPn50W4cS4rdO4TusU92KJMMKJTBQiVqWINsJi749IRDgS4UQmyhKxZ9UjnMhEISrRlog9OyIR/R1rjlAi5Pl20olMFCLkFvea3bEpQpaIDWXxLmL7jKhEWyI2y4hExKp4X7FZRhjhRDga0ZaIrTEiEfFv4l3ESZ4jTvKIRAihhBFO9Lds8w1z3MuXt7fthrv+Ly/n/T5u+v/6MaD/cPC8O+9PL5uH0+vxuN38tzu+zv/o5/PuNM+X3bl/tR+h/elbnx38fjjuo962f1ZP60vjKj+vNbks9n9Xp/XVGpfpeXm/qqytv/LsKe5x5vX9lm5tva6vz3F65vXZ2i2v3xuvP/sN6/vHjMOXVt9/Xl9fOPqlXFabvvvZRS8nL689e73r2a+s7t+UOXZTXT12V05+bWkBmvw5+SL/AukDgRIfxnEE6rQG1I9bL5kT2O+dVg+h33sE8gcC7zoEVzZB4wi0esP1wzOrVz/9cmV5nvj45+Q3Ae+5/lwFWuXwTasXYLlyBfTKK/B2G2AcQ3e/4RQYb6D/rmX1+e/dgVI+EHjXFtY7z6FOd57Dq8Cd57D/2uvybdhWX4DeeQ7UPhC49zrUfw/BpThNtxzCXC/rV+8EtN55LboKvOdadBV4zz62dOc+vgrcu4/zdDkJ6y/g3m1o/oHA+j7+3B/tHg/nf/5Q8BbS+bD7etwvD7+/nh7/+urL/898hT80PJ+fHvffXs/7kP78taH/2PLJqm+t+ef4dXc8LG1r1eJhioct96/Wz2/xYn4D", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index ed244e34903..b1a9be1926a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32859 }, 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(32858), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32858) }, Call { location: 13 }, Call { location: 37 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32859 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Field, 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: Field, value: 1 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32841), bit_size: Field, value: 2 }, Const { destination: Direct(32842), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32843), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32844), bit_size: Field, value: 4 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32846), bit_size: Field, value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 10 }, Const { destination: Direct(32852), bit_size: Field, value: 10 }, Const { destination: Direct(32853), bit_size: Field, value: 15 }, Const { destination: Direct(32854), bit_size: Integer(U32), value: 20 }, Const { destination: Direct(32855), bit_size: Field, value: 20 }, Const { destination: Direct(32856), bit_size: Field, value: 22 }, Const { destination: Direct(32857), bit_size: Field, value: 30 }, Return, Call { location: 54 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 42 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32843) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 46 }, Call { location: 60 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, Mov { destination: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 63 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 59 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: 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(4) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 84 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 303 }, Jump { location: 87 }, Load { destination: Relative(3), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(4) }, 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: 95 }, Call { location: 326 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(5), location: 101 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 107 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Direct(32845) }, Mov { destination: Relative(9), source: Relative(4) }, Mov { destination: Relative(10), source: Relative(1) }, Mov { destination: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 329 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 124 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Direct(32845) }, Mov { destination: Relative(10), source: Relative(4) }, Mov { destination: Relative(11), source: Relative(1) }, Mov { destination: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 434 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 141 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Direct(32845) }, Mov { destination: Relative(11), source: Relative(4) }, Mov { destination: Relative(12), source: Relative(1) }, Mov { destination: Relative(13), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 530 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 158 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(10), location: 164 }, Call { location: 737 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, Mov { destination: Relative(15), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(10) }, Call { location: 740 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(3) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 179 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 855 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Field, value: 3 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Direct(32836) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32839) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32841) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32844) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Relative(11) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 904 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(3) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 218 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Direct(32845) }, Mov { destination: Relative(14), source: Relative(4) }, Mov { destination: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 948 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 234 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 13 }, Mov { destination: Relative(13), source: Direct(0) }, Mov { destination: Relative(14), source: Direct(32845) }, Mov { destination: Relative(15), source: Relative(4) }, Mov { destination: Relative(16), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1002 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 14 }, Mov { destination: Relative(14), source: Direct(0) }, Mov { destination: Relative(15), source: Direct(32845) }, Mov { destination: Relative(16), source: Relative(4) }, Mov { destination: Relative(17), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1403 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 266 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 15 }, Mov { destination: Relative(15), source: Direct(0) }, Mov { destination: Relative(16), source: Direct(32845) }, Mov { destination: Relative(17), source: Relative(4) }, Mov { destination: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1538 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 282 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1739 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 2013 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Load { destination: Relative(4), source_pointer: Relative(5) }, Load { destination: Relative(7), source_pointer: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(7) }, 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: 311 }, Call { location: 326 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Store { destination_pointer: Relative(6), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 84 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 335 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 343 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 346 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 354 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 370 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 373 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 379 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 391 }, Jump { location: 382 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 414 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 402 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 405 }, Call { location: 2274 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 414 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32842), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 418 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32841) }, JumpIf { condition: Relative(4), location: 424 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 427 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 433 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 440 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 448 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 451 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 459 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 475 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 478 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 484 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, JumpIf { condition: Relative(2), location: 496 }, Jump { location: 487 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 519 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 507 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 510 }, Call { location: 2274 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 519 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 523 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 529 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 538 }, Call { location: 2274 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 546 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 549 }, Call { location: 2274 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 557 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 574 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 577 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 583 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 596 }, Jump { location: 586 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Jump { location: 664 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(7), location: 618 }, Jump { location: 608 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 664 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 658 }, Jump { location: 621 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 634 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 651 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 657 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 663 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Direct(32841), rhs: Direct(32856) }, JumpIf { condition: Relative(1), location: 662 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 663 }, Jump { location: 664 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 669 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32852) }, JumpIf { condition: Relative(4), location: 675 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 681 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 687 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 693 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(7), location: 701 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 707 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 724 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 730 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 736 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 746 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 754 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 757 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32841) }, JumpIf { condition: Relative(7), location: 765 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 781 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 784 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 790 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 803 }, Jump { location: 794 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(4), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Jump { location: 845 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2277 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(2), location: 836 }, Jump { location: 814 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32843) }, JumpIf { condition: Relative(2), location: 817 }, Jump { location: 826 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32846) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 826 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 829 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 835 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 845 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 845 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 848 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 854 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 874 }, Jump { location: 863 }, JumpIf { condition: Relative(6), location: 865 }, Call { location: 2274 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 873 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 893 }, JumpIf { condition: Relative(6), location: 876 }, Call { location: 2274 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 884 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 893 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 897 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 903 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 922 }, Jump { location: 912 }, JumpIf { condition: Relative(5), location: 914 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(4), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 921 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 940 }, JumpIf { condition: Relative(5), location: 924 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(4), rhs: Direct(32844) }, JumpIf { condition: Relative(5), location: 931 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2303 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Store { destination_pointer: Relative(6), source: Direct(32841) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 940 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32841) }, JumpIf { condition: Relative(1), location: 947 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 980 }, Jump { location: 956 }, JumpIf { condition: Relative(6), location: 958 }, Call { location: 2274 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 966 }, 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: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Sub, lhs: Relative(5), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 991 }, JumpIf { condition: Relative(6), location: 982 }, Call { location: 2274 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 990 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 991 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 995 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 1001 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1041 }, Jump { location: 1013 }, JumpIf { condition: Relative(7), location: 1015 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(3), location: 1023 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1029 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1382 }, JumpIf { condition: Relative(7), location: 1043 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1051 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1064 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1076 }, Call { location: 2274 }, Mov { destination: Direct(32771), source: Relative(8) }, Call { location: 2277 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Load { destination: Relative(6), source_pointer: Relative(1) }, 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: 1089 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1095 }, Call { location: 60 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1098 }, Call { location: 2274 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(9), rhs: Direct(32852) }, JumpIf { condition: Relative(6), location: 1106 }, 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(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1112 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1118 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2277 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Load { destination: Relative(2), source_pointer: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1138 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(2), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2325 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 1151 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32842) }, Load { destination: Relative(1), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(12), location: 1157 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1163 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1169 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(10), location: 1175 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1181 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2325 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Store { destination_pointer: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 1194 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, Load { destination: Relative(11), source_pointer: Relative(14) }, BinaryFieldOp { destination: Relative(14), op: Equals, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(14), location: 1200 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1206 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, JumpIf { condition: Relative(11), location: 1212 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32850) }, Load { destination: Relative(11), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(11), rhs: Direct(32857) }, JumpIf { condition: Relative(12), location: 1218 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1224 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2380 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Load { destination: Relative(16), source_pointer: Relative(17) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1239 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(16), rhs: Direct(32852) }, JumpIf { condition: Relative(13), location: 1245 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1251 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(13), location: 1257 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(20) }, Load { destination: Relative(13), source_pointer: Relative(19) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2417 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1269 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(18) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1275 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1281 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Direct(32840), rhs: Relative(3) }, JumpIf { condition: Relative(11), location: 1285 }, Call { location: 60 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(11), location: 1288 }, Call { location: 2274 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(19), rhs: Relative(1) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Mov { destination: Direct(32772), source: Relative(19) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2459 }, Mov { destination: Relative(15), source: Direct(32774) }, Mov { destination: Relative(20), source: Direct(32775) }, Store { destination_pointer: Relative(20), source: Direct(32855) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1301 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32845) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(18), location: 1307 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32847), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1310 }, Call { location: 2274 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(18), location: 1316 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1322 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1328 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1334 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(19), location: 1340 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(3), location: 1343 }, Call { location: 2274 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(20) }, Load { destination: Relative(21), source_pointer: Relative(22) }, Mov { destination: Direct(32771), source: Relative(15) }, Mov { destination: Direct(32772), source: Relative(20) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2528 }, Mov { destination: Relative(19), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1361 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(19) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(1), location: 1369 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 1375 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1381 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Jump { location: 1382 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1390 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1396 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(2), location: 1402 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1454 }, Jump { location: 1414 }, JumpIf { condition: Relative(7), location: 1416 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1424 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1442 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1474 }, JumpIf { condition: Relative(7), location: 1456 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1464 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1474 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1482 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1488 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1494 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(7), location: 1502 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1508 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1525 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 1531 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 1537 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1589 }, Jump { location: 1549 }, JumpIf { condition: Relative(7), location: 1551 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1559 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1577 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 1609 }, JumpIf { condition: Relative(7), location: 1591 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1599 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1609 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1617 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1623 }, 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(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1629 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 1637 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1640 }, Jump { location: 1660 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1648 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1660 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1668 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1683 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1689 }, 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(7) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1695 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(8), location: 1703 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1709 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(9) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1726 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, JumpIf { condition: Relative(4), location: 1732 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(1), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(4), location: 1738 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Cast { destination: Relative(9), source: Relative(3), bit_size: Field }, Const { destination: Relative(10), bit_size: Field, value: 50 }, JumpIf { condition: Relative(7), location: 1795 }, Jump { location: 1752 }, JumpIf { condition: Relative(8), location: 1754 }, Call { location: 2274 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1767 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(2) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1783 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1827 }, JumpIf { condition: Relative(8), location: 1797 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(4), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1815 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 1827 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1835 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1852 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32849) }, JumpIf { condition: Relative(1), location: 1858 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1861 }, Jump { location: 1879 }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1867 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1879 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, 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: 1887 }, Call { location: 326 }, 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(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Store { destination_pointer: Relative(6), source: Relative(9) }, JumpIf { condition: Relative(1), location: 1918 }, Jump { location: 1900 }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 1906 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 1918 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1926 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1944 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1951 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1954 }, Call { location: 2274 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(5), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 1962 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 1968 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(3), rhs: Direct(32857) }, JumpIf { condition: Relative(6), location: 1976 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1982 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32853) }, JumpIf { condition: Relative(1), location: 1990 }, 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(9) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1996 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 2005 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 2012 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(9), source: Relative(4), bit_size: Field }, JumpIf { condition: Relative(7), location: 2115 }, Jump { location: 2025 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 2028 }, Call { location: 2274 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2277 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32846) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2041 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(10) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 2056 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(2) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2071 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 2077 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2083 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2380 }, Mov { destination: Relative(12), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(12) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(14) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 2098 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 2106 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 2112 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 2133 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2121 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Jump { location: 2133 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2141 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2158 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 2164 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 2167 }, Jump { location: 2185 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2173 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2218 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 2185 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2380 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2200 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Direct(32857) }, JumpIf { condition: Relative(1), location: 2206 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2380 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 2217 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2229 }, Jump { location: 2246 }, JumpIf { condition: Direct(32781), location: 2231 }, Jump { location: 2235 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2245 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2245 }, Jump { location: 2258 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2258 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2272 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2272 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2265 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2281 }, Jump { location: 2283 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2302 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2300 }, 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: 2293 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2302 }, 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: 2307 }, Jump { location: 2309 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2324 }, 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: 2321 }, 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: 2314 }, 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: 2324 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2336 }, Jump { location: 2353 }, JumpIf { condition: Direct(32781), location: 2338 }, Jump { location: 2342 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2352 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2352 }, Jump { location: 2365 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2365 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2378 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2371 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2389 }, Jump { location: 2393 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2415 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2414 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2407 }, Jump { location: 2415 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2427 }, Jump { location: 2435 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2458 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2457 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2450 }, Jump { location: 2458 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2470 }, Jump { location: 2487 }, JumpIf { condition: Direct(32782), location: 2472 }, Jump { location: 2476 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2486 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2486 }, Jump { location: 2499 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2499 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2513 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2513 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2506 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2527 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2520 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2537 }, Jump { location: 2543 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2565 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2564 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2557 }, Jump { location: 2565 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2580 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2573 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32859 }, 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(32858), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32858) }, Call { location: 13 }, Call { location: 37 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32859 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Field, 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: Field, value: 1 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32841), bit_size: Field, value: 2 }, Const { destination: Direct(32842), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32843), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32844), bit_size: Field, value: 4 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32846), bit_size: Field, value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 10 }, Const { destination: Direct(32852), bit_size: Field, value: 10 }, Const { destination: Direct(32853), bit_size: Field, value: 15 }, Const { destination: Direct(32854), bit_size: Integer(U32), value: 20 }, Const { destination: Direct(32855), bit_size: Field, value: 20 }, Const { destination: Direct(32856), bit_size: Field, value: 22 }, Const { destination: Direct(32857), bit_size: Field, value: 30 }, Return, Call { location: 54 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 42 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32843) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 46 }, Call { location: 60 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, Mov { destination: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 63 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 59 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: 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(4) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 84 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 303 }, Jump { location: 87 }, Load { destination: Relative(3), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(4) }, 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: 95 }, Call { location: 326 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(5), location: 101 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 107 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Direct(32845) }, Mov { destination: Relative(9), source: Relative(4) }, Mov { destination: Relative(10), source: Relative(1) }, Mov { destination: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 329 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 124 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Direct(32845) }, Mov { destination: Relative(10), source: Relative(4) }, Mov { destination: Relative(11), source: Relative(1) }, Mov { destination: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 434 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 141 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Direct(32845) }, Mov { destination: Relative(11), source: Relative(4) }, Mov { destination: Relative(12), source: Relative(1) }, Mov { destination: Relative(13), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 530 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 158 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(10), location: 164 }, Call { location: 748 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, Mov { destination: Relative(15), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(10) }, Call { location: 751 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(3) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 179 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 866 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Field, value: 3 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Direct(32836) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32839) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32841) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32844) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Relative(11) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 915 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(3) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 218 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Direct(32845) }, Mov { destination: Relative(14), source: Relative(4) }, Mov { destination: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 959 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 234 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 13 }, Mov { destination: Relative(13), source: Direct(0) }, Mov { destination: Relative(14), source: Direct(32845) }, Mov { destination: Relative(15), source: Relative(4) }, Mov { destination: Relative(16), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1013 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 14 }, Mov { destination: Relative(14), source: Direct(0) }, Mov { destination: Relative(15), source: Direct(32845) }, Mov { destination: Relative(16), source: Relative(4) }, Mov { destination: Relative(17), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1414 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 266 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 15 }, Mov { destination: Relative(15), source: Direct(0) }, Mov { destination: Relative(16), source: Direct(32845) }, Mov { destination: Relative(17), source: Relative(4) }, Mov { destination: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1549 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 282 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1750 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 2024 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Load { destination: Relative(4), source_pointer: Relative(5) }, Load { destination: Relative(7), source_pointer: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(7) }, 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: 311 }, Call { location: 326 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Store { destination_pointer: Relative(6), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 84 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 335 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 343 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 346 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 354 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 370 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 373 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 379 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 391 }, Jump { location: 382 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 414 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 402 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 405 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 414 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32842), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 418 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32841) }, JumpIf { condition: Relative(4), location: 424 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 427 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 433 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 440 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 448 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 451 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 459 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 475 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 478 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 484 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, JumpIf { condition: Relative(2), location: 496 }, Jump { location: 487 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 519 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 507 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 510 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 519 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 523 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 529 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 538 }, Call { location: 2285 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 546 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 549 }, Call { location: 2285 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 557 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 574 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 577 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 583 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 596 }, Jump { location: 586 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Jump { location: 675 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(7), location: 618 }, Jump { location: 608 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 675 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 658 }, Jump { location: 621 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 634 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 651 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 657 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 663 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Direct(32841), rhs: Direct(32856) }, JumpIf { condition: Relative(1), location: 662 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 663 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 668 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 674 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 675 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 680 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32852) }, JumpIf { condition: Relative(4), location: 686 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 692 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 698 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 704 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(7), location: 712 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 718 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 735 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 741 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 747 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 757 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 765 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 768 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32841) }, JumpIf { condition: Relative(7), location: 776 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 792 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 795 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 801 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 814 }, Jump { location: 805 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(4), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Jump { location: 856 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(2), location: 847 }, Jump { location: 825 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32843) }, JumpIf { condition: Relative(2), location: 828 }, Jump { location: 837 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32846) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 837 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 840 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 846 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 856 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 856 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 859 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 865 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 885 }, Jump { location: 874 }, JumpIf { condition: Relative(6), location: 876 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 884 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 904 }, JumpIf { condition: Relative(6), location: 887 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 895 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 904 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 908 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 914 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 933 }, Jump { location: 923 }, JumpIf { condition: Relative(5), location: 925 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(4), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 932 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 951 }, JumpIf { condition: Relative(5), location: 935 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(4), rhs: Direct(32844) }, JumpIf { condition: Relative(5), location: 942 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2314 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Store { destination_pointer: Relative(6), source: Direct(32841) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 951 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32841) }, JumpIf { condition: Relative(1), location: 958 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 991 }, Jump { location: 967 }, JumpIf { condition: Relative(6), location: 969 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 977 }, 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: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Sub, lhs: Relative(5), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 1002 }, JumpIf { condition: Relative(6), location: 993 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 1001 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 1002 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1006 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 1012 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1052 }, Jump { location: 1024 }, JumpIf { condition: Relative(7), location: 1026 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(3), location: 1034 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1040 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1393 }, JumpIf { condition: Relative(7), location: 1054 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1062 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1075 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1087 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(8) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Load { destination: Relative(6), source_pointer: Relative(1) }, 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: 1100 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1106 }, Call { location: 60 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1109 }, Call { location: 2285 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(9), rhs: Direct(32852) }, JumpIf { condition: Relative(6), location: 1117 }, 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(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1123 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1129 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Load { destination: Relative(2), source_pointer: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1149 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(2), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2336 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 1162 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32842) }, Load { destination: Relative(1), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(12), location: 1168 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1174 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1180 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(10), location: 1186 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1192 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2336 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Store { destination_pointer: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 1205 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, Load { destination: Relative(11), source_pointer: Relative(14) }, BinaryFieldOp { destination: Relative(14), op: Equals, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(14), location: 1211 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1217 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, JumpIf { condition: Relative(11), location: 1223 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32850) }, Load { destination: Relative(11), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(11), rhs: Direct(32857) }, JumpIf { condition: Relative(12), location: 1229 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1235 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Load { destination: Relative(16), source_pointer: Relative(17) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(16), rhs: Direct(32852) }, JumpIf { condition: Relative(13), location: 1256 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1262 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(13), location: 1268 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(20) }, Load { destination: Relative(13), source_pointer: Relative(19) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2428 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1280 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(18) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1286 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1292 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Direct(32840), rhs: Relative(3) }, JumpIf { condition: Relative(11), location: 1296 }, Call { location: 60 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(11), location: 1299 }, Call { location: 2285 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(19), rhs: Relative(1) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Mov { destination: Direct(32772), source: Relative(19) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2470 }, Mov { destination: Relative(15), source: Direct(32774) }, Mov { destination: Relative(20), source: Direct(32775) }, Store { destination_pointer: Relative(20), source: Direct(32855) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1312 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32845) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(18), location: 1318 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32847), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1321 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(18), location: 1327 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1333 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1339 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1345 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(19), location: 1351 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(3), location: 1354 }, Call { location: 2285 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(20) }, Load { destination: Relative(21), source_pointer: Relative(22) }, Mov { destination: Direct(32771), source: Relative(15) }, Mov { destination: Direct(32772), source: Relative(20) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2539 }, Mov { destination: Relative(19), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1372 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(19) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(1), location: 1380 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 1386 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1392 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Jump { location: 1393 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1401 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1407 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(2), location: 1413 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1465 }, Jump { location: 1425 }, JumpIf { condition: Relative(7), location: 1427 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1435 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1453 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1485 }, JumpIf { condition: Relative(7), location: 1467 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1475 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1485 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1493 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1499 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1505 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(7), location: 1513 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1519 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1536 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 1542 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 1548 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1600 }, Jump { location: 1560 }, JumpIf { condition: Relative(7), location: 1562 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1570 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1588 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 1620 }, JumpIf { condition: Relative(7), location: 1602 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1610 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1620 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1628 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1634 }, 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(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1640 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 1648 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1651 }, Jump { location: 1671 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1659 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1671 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1679 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1694 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1700 }, 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(7) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1706 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(8), location: 1714 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1720 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(9) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1737 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, JumpIf { condition: Relative(4), location: 1743 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(1), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(4), location: 1749 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Cast { destination: Relative(9), source: Relative(3), bit_size: Field }, Const { destination: Relative(10), bit_size: Field, value: 50 }, JumpIf { condition: Relative(7), location: 1806 }, Jump { location: 1763 }, JumpIf { condition: Relative(8), location: 1765 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1778 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(2) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1794 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1838 }, JumpIf { condition: Relative(8), location: 1808 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(4), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1826 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 1838 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1846 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1863 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32849) }, JumpIf { condition: Relative(1), location: 1869 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1872 }, Jump { location: 1890 }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1878 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1890 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, 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: 1898 }, Call { location: 326 }, 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(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Store { destination_pointer: Relative(6), source: Relative(9) }, JumpIf { condition: Relative(1), location: 1929 }, Jump { location: 1911 }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 1917 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 1929 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1937 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1955 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1962 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1965 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(5), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 1973 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 1979 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(3), rhs: Direct(32857) }, JumpIf { condition: Relative(6), location: 1987 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1993 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32853) }, JumpIf { condition: Relative(1), location: 2001 }, 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(9) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2007 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 2016 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 2023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(9), source: Relative(4), bit_size: Field }, JumpIf { condition: Relative(7), location: 2126 }, Jump { location: 2036 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 2039 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32846) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2052 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(10) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 2067 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(2) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2082 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 2088 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2094 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(12), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(12) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(14) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 2109 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 2117 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 2123 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 2144 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2132 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Jump { location: 2144 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2152 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2169 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 2175 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 2178 }, Jump { location: 2196 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2184 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 2196 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2211 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Direct(32857) }, JumpIf { condition: Relative(1), location: 2217 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 2228 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2240 }, Jump { location: 2257 }, JumpIf { condition: Direct(32781), location: 2242 }, Jump { location: 2246 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2256 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2256 }, Jump { location: 2269 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2269 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2283 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2283 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2276 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2292 }, Jump { location: 2294 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2313 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2311 }, 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: 2304 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2313 }, 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: 2318 }, Jump { location: 2320 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2335 }, 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: 2332 }, 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: 2325 }, 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: 2335 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2347 }, Jump { location: 2364 }, JumpIf { condition: Direct(32781), location: 2349 }, Jump { location: 2353 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2363 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2363 }, Jump { location: 2376 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2376 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2389 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2382 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2400 }, Jump { location: 2404 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2426 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2425 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2418 }, Jump { location: 2426 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2438 }, Jump { location: 2446 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2469 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2468 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2461 }, Jump { location: 2469 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2481 }, Jump { location: 2498 }, JumpIf { condition: Direct(32782), location: 2483 }, Jump { location: 2487 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2497 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2497 }, Jump { location: 2510 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2510 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2524 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2524 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2517 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2538 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2531 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2548 }, Jump { location: 2554 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2576 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2575 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2568 }, Jump { location: 2576 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2591 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2584 }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap index 915ac59b8e8..8e531d3e5db 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2062 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2068 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2068 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2039 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2074 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2074 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2077 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2077 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2074 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2074 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2077 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2074 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2074 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 423 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 423 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Jump { location: 423 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 428 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 434 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 440 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 446 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 452 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 461 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 467 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 485 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 491 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 498 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 506 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 512 }, Call { location: 2159 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 517 }, Call { location: 2074 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 525 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2074 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2077 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 552 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 556 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 562 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 575 }, Jump { location: 566 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 617 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 608 }, Jump { location: 586 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 589 }, Jump { location: 598 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 598 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 601 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 607 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 617 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 617 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 620 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 626 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 634 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 653 }, Jump { location: 642 }, JumpIf { condition: Relative(29), location: 644 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 652 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 672 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 663 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 672 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 676 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 682 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 711 }, Jump { location: 703 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 710 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 727 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 718 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2162 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 727 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 734 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 742 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 774 }, Jump { location: 750 }, JumpIf { condition: Relative(29), location: 752 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 760 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 785 }, JumpIf { condition: Relative(29), location: 776 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 784 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 785 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 789 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 795 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 803 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 843 }, Jump { location: 815 }, JumpIf { condition: Relative(29), location: 817 }, Call { location: 2074 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 825 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 831 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1185 }, JumpIf { condition: Relative(29), location: 845 }, Call { location: 2074 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 853 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 866 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 878 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 891 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 897 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 900 }, Call { location: 2074 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 908 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 914 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 920 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2077 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 940 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2184 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 953 }, Call { location: 2074 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 960 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 966 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 972 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 978 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 984 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2184 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 997 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1003 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1009 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1015 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1021 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1027 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1042 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1048 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1054 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1060 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2276 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1072 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1078 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1084 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1088 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1091 }, Call { location: 2074 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2318 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1104 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1110 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1113 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1119 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1125 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1131 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1137 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1143 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1146 }, Call { location: 2074 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2387 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1164 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1172 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1178 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1184 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1185 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1193 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1199 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1205 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1213 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1264 }, Jump { location: 1224 }, JumpIf { condition: Relative(22), location: 1226 }, Call { location: 2074 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1234 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1252 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1284 }, JumpIf { condition: Relative(22), location: 1266 }, Call { location: 2074 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1274 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1284 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1292 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1298 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1304 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1312 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1318 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1335 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1341 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1347 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1355 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1406 }, Jump { location: 1366 }, JumpIf { condition: Relative(27), location: 1368 }, Call { location: 2074 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1376 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1394 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1426 }, JumpIf { condition: Relative(27), location: 1408 }, Call { location: 2074 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1416 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1426 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1434 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1440 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1446 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1454 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1458 }, Jump { location: 1478 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1466 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1478 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1486 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1501 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1507 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1513 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1521 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1527 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1544 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1550 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1556 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1564 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1621 }, Jump { location: 1579 }, JumpIf { condition: Relative(22), location: 1581 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1594 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1609 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1653 }, JumpIf { condition: Relative(22), location: 1623 }, Call { location: 2074 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1641 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1653 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1661 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1678 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1684 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1686 }, Jump { location: 1704 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1692 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1704 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1712 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1743 }, Jump { location: 1725 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1731 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1743 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1751 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1769 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1776 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1779 }, Call { location: 2074 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1793 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1801 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1807 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1815 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1821 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1830 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1837 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1937 }, Jump { location: 1847 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1850 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1863 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1878 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1893 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1899 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1905 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1920 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1928 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1934 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1955 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1943 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1955 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1963 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1980 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1986 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1988 }, Jump { location: 2006 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 1994 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2006 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2021 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2027 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2038 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2047 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2067 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2081 }, Jump { location: 2083 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2102 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2100 }, 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: 2093 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2102 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2114 }, Jump { location: 2131 }, JumpIf { condition: Direct(32781), location: 2116 }, Jump { location: 2120 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2130 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2130 }, Jump { location: 2143 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2143 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2157 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2157 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2150 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2166 }, Jump { location: 2168 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2183 }, 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: 2180 }, 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: 2173 }, 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: 2183 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2195 }, Jump { location: 2212 }, JumpIf { condition: Direct(32781), location: 2197 }, Jump { location: 2201 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2211 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2211 }, Jump { location: 2224 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2224 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2237 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2230 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2248 }, Jump { location: 2252 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2274 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2273 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2266 }, Jump { location: 2274 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2286 }, Jump { location: 2294 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2317 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2316 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2309 }, Jump { location: 2317 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2329 }, Jump { location: 2346 }, JumpIf { condition: Direct(32782), location: 2331 }, Jump { location: 2335 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2345 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2345 }, Jump { location: 2358 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2358 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2372 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2372 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2365 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2386 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2379 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2396 }, Jump { location: 2402 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2424 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2423 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2416 }, Jump { location: 2424 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2439 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2432 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2073 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2079 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2079 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2050 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2085 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2088 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 434 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 434 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 427 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 433 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 434 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 439 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 445 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 451 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 457 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 463 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 472 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 478 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 496 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 502 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 509 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 517 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 523 }, Call { location: 2170 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 539 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 547 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2088 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 563 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 567 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 573 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 586 }, Jump { location: 577 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 619 }, Jump { location: 597 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 600 }, Jump { location: 609 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 609 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 612 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 618 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 628 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 631 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 637 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 645 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 664 }, Jump { location: 653 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 663 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 683 }, JumpIf { condition: Relative(29), location: 666 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 674 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 683 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 687 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 693 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 722 }, Jump { location: 714 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 721 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 738 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 729 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2173 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 738 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 745 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 753 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 785 }, Jump { location: 761 }, JumpIf { condition: Relative(29), location: 763 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 771 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 796 }, JumpIf { condition: Relative(29), location: 787 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 795 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 796 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 800 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 806 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 814 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 854 }, Jump { location: 826 }, JumpIf { condition: Relative(29), location: 828 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 836 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 842 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1196 }, JumpIf { condition: Relative(29), location: 856 }, Call { location: 2085 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 864 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 877 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 889 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 902 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 908 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 911 }, Call { location: 2085 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 919 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 925 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 931 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 951 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 964 }, Call { location: 2085 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 971 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 977 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 983 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 989 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 995 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1008 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1014 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1020 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1026 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1032 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1038 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1053 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1059 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1065 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1071 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2287 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1083 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1089 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1095 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1099 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1102 }, Call { location: 2085 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2329 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1115 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1121 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1124 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1130 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1136 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1142 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1148 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1154 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1157 }, Call { location: 2085 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2398 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1175 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1183 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1189 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1195 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1196 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1204 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1210 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1216 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1224 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1275 }, Jump { location: 1235 }, JumpIf { condition: Relative(22), location: 1237 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1245 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1263 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1295 }, JumpIf { condition: Relative(22), location: 1277 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1285 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1295 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1303 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1309 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1315 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1323 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1329 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1346 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1352 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1358 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1366 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1417 }, Jump { location: 1377 }, JumpIf { condition: Relative(27), location: 1379 }, Call { location: 2085 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1387 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1405 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1437 }, JumpIf { condition: Relative(27), location: 1419 }, Call { location: 2085 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1427 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1437 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1445 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1451 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1457 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1465 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1469 }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1477 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1497 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1512 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1518 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1524 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1532 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1538 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1555 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1561 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1567 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1575 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1632 }, Jump { location: 1590 }, JumpIf { condition: Relative(22), location: 1592 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1605 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1620 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1664 }, JumpIf { condition: Relative(22), location: 1634 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1652 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1664 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1672 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1689 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1695 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1697 }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1703 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1723 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1754 }, Jump { location: 1736 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1742 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1754 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1762 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1780 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1790 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1798 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1804 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1812 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1818 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1826 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1832 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1841 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1848 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1948 }, Jump { location: 1858 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1861 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1874 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1889 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1904 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1910 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1916 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1931 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1939 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1945 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1966 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1954 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1966 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1974 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1991 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1997 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1999 }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2005 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2032 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2038 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2049 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2058 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2078 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2092 }, Jump { location: 2094 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2113 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2111 }, 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: 2104 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2113 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2125 }, Jump { location: 2142 }, JumpIf { condition: Direct(32781), location: 2127 }, Jump { location: 2131 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2141 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2141 }, Jump { location: 2154 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2154 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2168 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2168 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2161 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2177 }, Jump { location: 2179 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2194 }, 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: 2191 }, 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: 2184 }, 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: 2194 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2206 }, Jump { location: 2223 }, JumpIf { condition: Direct(32781), location: 2208 }, Jump { location: 2212 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2222 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2222 }, Jump { location: 2235 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2235 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2248 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2241 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2259 }, Jump { location: 2263 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2285 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2284 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2277 }, Jump { location: 2285 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2297 }, Jump { location: 2305 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2328 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2327 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2320 }, Jump { location: 2328 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2340 }, Jump { location: 2357 }, JumpIf { condition: Direct(32782), location: 2342 }, Jump { location: 2346 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2356 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2356 }, Jump { location: 2369 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2369 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2383 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2383 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2376 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2397 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2390 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2407 }, Jump { location: 2413 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2435 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2434 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2427 }, Jump { location: 2435 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2450 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2443 }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "td3Rrt02rgbgd8l1LyxRJMV5lcGg6HQygwBBW2TaAxwUffdjUiL/9GI5qXbOTf3tJOunl2xp2bLW7u/v/vX+n7/95/sPP/375/+++9vff3/3z08fPn788J/vP/784w+/fvj5p/tPf393+X8av/tb++5dk7XRtZlrY7Hp9z/s96atTV8bWpuxNnfKuDeyNro2c20sNnStTVubvja0NmNtVgqtFFoptFJopYyVMlbKWCljpYz7BfzdO77/idybtjZ9bWhtxtrw2sja6NrMtbHYyJ2i96atTV8bWpuxNrw2sja6NnNtLDa6UnSl6J1i94bWZqwNr42sja6NH4Dr3trazmtv297eSe0+NJP2duwt763sre7t3FtbW/O8+7hZ29u+t7S3nkf3lvdW9lb3du6t591N364r0RI9QYmR4IQkNOHB7LCNdiVawpPFQYmR4IQnq0MTnjwdtuHn9UJLeLI5KHG/vF+OmbANP6EXWqInKDES9/5071J+Vi/MhG34ub3QEj3hgd0xEpyQhCeTYyZsw7tE9+b1TrHQE5QYCU5IQhP53r13dD8W3j8WesID/RB4L1nghCQ80A+K95YF2/Ae0/1YeJ9Z6AlK3Mmx5b2VvdW9nXtra+u9J7Ztb/ve0t7eeeRvy7vPgiQ0MRN3KMXgeCVaoifuYPJj4v1ogROS0MRM2EL3zkTkaImeoIQn++jqnWlBEprwZHbYhnemhZboCUqMBCc8WRyamAnb8M5E6miJnqCEJ08HJyThyeaYCR/wL/+guRIt0RM+8PsnVHxkxKeSJmbCNuKjI9ASPUEJ/wTy5vVetaCJmbAN71ULLeGB3vLeqxZGghOe7K3qvWphJjzZG9O710JL9AQlRoITksj37r1qeMt7r1poCQ/0lvdeteCB3vLerRYkoQnvrwHb8L610BI9QYmR4IQkNHEnsx9K718B718LLdETlBiJO5n9LXv/WtDETHgy+ZXIlWiJnqDESHDCk+NCRhMzYRvev5gdLdETlPBkcXBCEpqYCdvw/rXQEj3hyeoYCU5IwpOnYyZsw/vXgieboyco4ddNl4MTfu3UHJqYCdvw3iTdIQlNzIRtxGVboCV6ghIe6McirtwCmpgJ2/BOtNASPUEJf19xyek5fnS87yzYhvedhZboCUqMBCc80I+OdxDxQ+AdZKEnKDESnJCEJmbCNiyTLZMtky2TLZO9g4gfZe8gC5qYCVsY3kEWWqInKDESnJCEJmYik1smt0z2DiLmoMRIcMKvrS/HTNiG94uFzOmZ491Bm4MTkvDA7pgJDyS/l7gSLdETY52HgzjhgXEHoomZ8MD7TBj+ubPggeLoCUqMBCckoYmZsA3vMguZzJnsXUbVMRKckIQmZsI24u4n0BI9kcmSyXEf5Icy7oQCmvBkPxZxP+SIO6JAS/QEJUaCE5LQRCZrJsdVnp8JcZkX6AlKjAQnJKGJmbANy2TLZMtky2TLZMtky2TLZO9o008/72gO9o620BKe3B2UGAlPJockNDETPqpffvd7JVqiJygxEpyQhCZmwvd5+A31lWiJnvB9jpvukeCEJDTh+6wO2/Cut9ASnjwdlBgJTkhCEzPhyea3/VeiJXrC78b9DXofXOCEJPyu3I+O98EF2/A+uNASPUGJkfBkP5TeBxc0MROe7IfS++BCS/SEJ3uDex9c4IQkPNmnQ7wPLnhyzHdciZboCU/2lo+JCG9D72gLtuEdbaEleoISI+H74+3s/WthJmzD+9dCS/QEJfwW//KDEXMQV/MpmpgV6a5W6iUqjRKXpKQlS3nvsZj+aYnIJReVIne4uCQlLUUu+zTSVWqlXqLSKHFJSvuQSI9gn62iqxTBMVnVSxHsr6BR4pKUvAd5hehBAduIHhRoiZ6gxEhwQhIxEXW5ZslS3omaz0sJU2mUYlLLDwtLSUuzFHl+YOQqtVIvRbIfGOFSJPueipZmyVIayd7O2kq9RKXae+WSlLQ0S5aa1Rox3bdEufdrqi9mGrkkpUj2Y7mm/EKRbD4peZVaqZdi8s+PR3S2JS5JSUuzZFsanXKplXqJSqPEJSlpaZaiRvfp1KvUSpFHLi5JKfKGa5YsFd1yKfaUXVQapUgWl5S0NEuR7DO+0S+XWqmXqDRKXJJS7TNF8vTZ46sUyTGj3EtUGqVIbi4paWmWLBX9cqmVeolKoxQTxiEpaSmmjf1oRb9c6iXP88ktjR66xCUpRZ63RvTQJUtFD12KGn7coocuUWmUooYft+ihPlWl0UOXZslS0UOXWqmXqBTJfoyihy5Fcszxz5KloocuVQtZtVD00KVRqn2OfjniqcEs2dZcM/T+DGBN0Ydijr67qDRKXIoakaKlWbJU9MulVuolKo0Sl+JZwHBpaZYsFX11qZXifbBLSlqKFHFZKvrlUitFirqoNEpckpKWZslS0UOXWqlqjKoRPdSn4Gb00CUpaWmWLBU9dKmVeimSzcUlT/Yr+hn9cmmWLBWfoRzPklqpl6jkNXx+bUZfXZKSlmbJUtFXl1qpl6hUNbRqaNXQqqFVI/qqT9vN6KtLrdRLVBolLkUNP8Oi1y7NUtTwMyx67VIr9RKVRolLUtLSLGUNu65SK/USlaKGuLgkJS3NkqXWs7ZQ1FBXL1FplKLGdElJS7Nkqei/S63US1QaparRq0b0bp+atOjdS5aK3r3kNXzC0qJ3L1FplLgkJS15DZ/StOjdoejdS63US1QaJS5JSUtVY1QNrhpcNbhqxOevT0NZ9PMlLklJS7NkqejnS1Ejnvb2EpWixnBxSUpRw8+/6OdLlop+vtRKvUSlUeKSlKqGVo3o5z7PatHPl1qpl6KGn7HRz5eihp9N0c+XtDRLlop+vtRKvUSlUaoaVjWin/sMpUU/X7Kt+x73AhvYQQIH6JV8JvSmgAp6MZ/9vGnF6PI+A3qzgR0kcIAMCqjgBK3YUa2jWnR/n2G9SeAAGYxqa4GBglEt1g3EKLAYw8BmAztI4AAZFFBBVCNUiwHBJ19vNrCDBA6QQQEVnKAVGdUY1RjVGNUY1WJ88FnbmwIqOEErxiCx2cAOEjhAVBNUi7HCp4dvTtCKMVxsRrU4wWPA2CRwgAwKqOAEYxFI9IsYODYb2EECB8iggApOENUM1WIMmdELYxDZJHCAUS16SwwkmwpOMKp5b1nLcjYb2EECB8iggApOENUaqjVUi7HEp4fbWrCzOcCotpb4CBjVYi3PWrqzaMW1fGcxqsUqnxhLNgmMarH6J8aSzahmQQUnaMUYSzYb2EECB8ggqhGqxVjik8wtFgJtxliy2cAOEjhABgVUENUGqsVY4hPULRYIJTtIYFTrQQYFVHCCVoyxZLOBHSQQ1QTVBNUE1QTVBNUU1RTVFNUU1RTVFNUU1RTVFNViLLE412Ms2WxgBwkcIIMCKjhBVDNUi7FkRMexDhI4wLy3bM0UnGDeXrZ+XWADO0jgABmMNzSCCk7QijGA+LOKFguUktF8EiRwgAzGe6OgghO04ppJWGxgBwkcIIPx3tbKQQUnaMUYQDYbGO9tLTlkUMBYgBgLD2PF4KYVY9XgZixEbMEOEjhAX4rjzzparHVKKjjBqBbvOFYSXnGwYi3hZgcJHCCDAio4QSsKqgmqCaoJqgmqxYLDK86dWHK4qeAErRhLDzcb2EECo0SccipglNDgBK0Yq6U2o0ScBLFiapPAAeLUmDg11viwOEErrvFhsYE45WJ82ESbGdrM0GaGNrNqs1hKlWxgBwkcYFSzoIAKTtCK7QIb2EECB4hqDdVarMSNxbltgrEaN9blxrr3zQZ2kMABMiigghNENUK1WFDsj7RaLMVKEjhABgVUcIJWXGuNF1FtoNpAtYFqA9UGqg1Ui1HDn1O1WNm1GaPGZgOj2ggSGNXiLIlRY1NABeO016AV1wXGYgM7SOAAGRRQwXhvi1aMUWOzgR0kMN7bDCo4wciN0zOGis0GdjDWhMdJG0PFJoMCerW97HyCVvShIunVYkV5rCfrsYI8VpQlB8iggApO0JKxvizZwA4SOEAGBYxqIzhBK8aosdnADhI4QAajBAcnGCV84I9VaMkGdjBKaHCADApYp8boE7TiGioWG9hBAgfIINqM0GaENhtos4E2G2izgTYbaLOBNlvfS1iMalE4xodNK8b4sNnADhI4QAYFRDVGtbiq8MegLRa3Jb1aLOuPBW5JAgfo1WJ5fyx0S1oxRoLNBnaQwAEiV5Eb48PmBKOa981Y7pZsYAcJHCCDAiqIEoYShhKGEoYShhKGEoYShhIxKGxGtfUdlQtsYAcJHCCDAio4QVRrqNZQraFaQ7UYFGh9f4ZBARWcoBVjfNhsYAcJRLWOajE++OPqFivoklFNglaM8WGzgR0kcIAMCqggqhGqxVDhD6BbrK5LdpDAATIooIITtCKjGqMaoxqjGqMaoxqjWgwV/lS+xfq7pBVjqNiMahbsoFfz5+st1uIlGRQwxvVos3UpsWjFdSmx2MAOEjhABgX0av70vsUSvqQVYwDZbGAH471FD4gBZMSJGANITCTE2r4+oiVjqFj/IIaKzQiL5ouhYnOADAqo4AQtGQv/kg3sIIEDZFDAqGbBCVoxhorNBnaQwAEyKCCqNVRrqNZRraNaDBX+XL7FKsHkABkUUMEJWjGGik2UIJSI8cEf9LdYMZgUUMEo0YNRws+dWDmYbGAHCRwggwIqOEFUY1RjVGNUY1SL8cEf5bdYY5gUUMEJWnF9D3KxgR1ECUEJQQlBCUEJQQlFCUUJRYkYFDajGgcZFFDBCVoxBoXNBnaQQFSbqDZRbaLaRLWJaoZqMWpwfDk0Ro1NAgcYuRqcoCVjDWKygR0kcIDxLmZQQAUnaMUYHzYb2EECUaKhREOJhhINJTpKdJToKNFRYg0Ki1HNggIqOEErrkFhsYEdJNBzfZHETQUnaMUYCTYb2EEC/V34MocW6xaTAio4QSvGSLDZwA6iBKMEowSjBKMEo4SghKCEoMT6MvRiVOtBBgVUcIJWjJFgs4EdJBDVFNUU1RTVFNUU1SaqTVSLkcDXg7RY5pgcIIMCKjhBK8ZI4CtJWix8THaQwKjGQQYFVHCCloy1kMkGdpDAATIY1SSoYFTToBVjfNhsYAcJHCCDAiqIag3VYqjwdSYtFkgmo5oFCRwggwIqOEErxlCx2UBUI1SLS4lYixKLKZMCerVYlhLrKZNWjAFk06vF8pFYU5kkMKpRkEEBFYwrsZVrxRhAYn1JLK5MdpDAATIY7yJOmBg1FmPU2IzcOHdi1NgkcIAMCqjgBK0Yo8YmqimqKaopqimqxagRSzdiqWVyglaMUWOzgR0kcIAMotpEtYlqE9UM1WLUiDUjsfIySeAAGRRQwQlaMlZgJhvYQQIHyGBUs6CCE7RijBqbDewggQNkENUaqsWoEQtQYlHmZowamw3sIIEDZFBABVGtoxqhGqEaoRqhGqEaoRqhGqEaoRqh2kC1GDViRU2s1UwSOEAGBZygFWOo2EQJRglGCUYJRom47Ij1O7FeMzlBK8YAstnADhI4QJQQlBCUEJRQlFCUUJRQlFCUiFFjM6pRUMEJWjFGjc0GdpDAATKIahPVJqpNVDNUM1QzVItRI9YmxUrOJIMCRi7Hb225wAZ2kMABMihgvAsJTtCKMT5sNrCDBA6QQZRoKLEGBY1fOnOBDewggQNkUEAFJ4hqhGqEaoRqhGprUJhBBgVUMKpZ0IprUFhsYAcJHKBX81VTPVZrJhWcRR8U4lj6kLDQE5QYCU5IQhMzYRsxAPh6rB7LMeO4xS+3CFBiJDghCU3MhG3Er7v444/v3uXvivv+10/v3/uvivvsl8f9/fd3v/zw6f1Pv77720+/ffz43bv/+eHjb/GP/vvLDz/F9tcfPt1/ezfE+5/+dW/vwH9/+Pje9cd3ePX1+qXxdZV48T0BXC/nr3+9Txas10s7eb0/Ktuv769eT/9/r48b4Xh9f73/T6+f9Xrjg9dTz/ajcbL/xFn/ftD86vXzof3UV/OsBrxnSE4SLl+0tBLuQfLNCXKUQFcl0HxrwqCjBEYCn+2D36/shElvTjjah/hq/kq4/eYEPkro9S7a2dGMebOVcN+xH+1DdWxfGHq0Dw370MdRQq/B7X4MeLYPhH04OhbxMbsTbL4xga6js5p8Yc9OOHsXnyfQdTLOWp6S4/WR8OUOrwLuZ59tJ9wPPO0kwpfI5LsYr9vhqyNeN8RzxKhPjMH97RF6FiGI0MO9mNVBh+lbI/g62wvuNVxyp7OIJogYb484OzuZ0BaH54VoDVf3k7GzvbA6L+TwiAhhL15//DxHjDqo98PSs4iu2IuzI6LtwrXdWXP+6fKwvz1CD8beUY05Xn8C8cNNhrQave8n/0cRY155do/5+l18dUTvZxEkFTHG2yPsLIIRIYd7UZ+GN+3NEXa2F9ZGnVmvL1WfI66JCHlzRG8nEUwzj8g9Ch+2BdcVzj21eRZhdUTMjvoIXy37+v15ep1F6FURenREuNcNKfd2dkR6DVrc+awt+mcH9ToaLxjTO/cHPJ2dWnWtdpPPImgiQt4cwWdtMXod1NHHWURdPfPDBfhXR9DZqTUGV4QcRigiDnvqZxF8nZ1aXHfIfJ8YZxFcd1UsZ2/kTzdm9PYIO7jE4fpE5aNpSK5rLH49DerPPF7OY169JjLvZwAnEax1fcNPU4lfG9H7WURd37C+vkT6+gg7i8ABVTncC5xUOu3NEXa2F7MukW7yWURd39wR8uaI15dITxHSavi/Oc4ias5Bmp6dnbOusnjKWTczqVPLzvZCrvoEkfu52VlEXWXdnGfNWR+F9xHhN0e8ns56bs5ZH8hmZ3sR3/bO28uzI/KnO1R6e8Q8+RCRWYf0ZVu26+Fe/57nznPznm62owxfjJLzBfb6mdgXMuqgtoeD+rUZvurgLGNqzYlNO30vmMWxNt+e8XqS8fnYXvWo0tcZnGbgKqPPt2e8vlJ5OM8xOSfj6PWX1Otfvwf/nu/L98D1SXLfHOpZBp7t9P76M/EvZMhZRqurpd5eX3D9hQw7zMCj/Hv2+LA9Ph+/xjfIOLkZEK7LjNdPHuP3ub6ciel10z7662uEx4w+ajfud6SHGTbrPL/k7RmvJ2OeM7im9O/D+i0y+DCjHvbccddhe9SFbH94FvkXju3h+cF1BXjztE0/Hwf7N8g4eb4gdeGkD59r4+kJhdTn/NDrMOOymlVvrx+1PGfE3+6M1xf2fyFDDjNqcmg0u44yumAclYdryecMrWs4mfz2jNP3onWHcPPwvWgdl66v1xc9ZxhXxj3ff5hRl093xmF7mNaYbkanGdiP15MbX5tBT9f4Txl01RJEumgcZtS5ThefZohVhp6NQdTq8Qu1Pg8zaoqDTscPwnOLO0PfniF0mFETaNTscD/i1yitjN7pG2TYYQba4x5QDzOszo9up++lHmvdGePNGXTabwn9lk77LXG1B8n1DTIO+8uo+3t6eLb1hYz6fLmf8x32/aFYzmyH5ynX5CQ9PNL5QgbOj4dVQM8ZUvMMJOOwTWXWe5HT8UPq+vaOO9wPrRW1Nw/PMa2ndXR6nfynDDocP5S1Mk7PU63Hhjft7Rmn46nO6nN62l+m4CsAeniuz1FtOg/bY1xSqz8engg8Z3QsyOl0HWZ8NvdxOJ5+5fzJQ4LWZIE+jGH+Kw9f3pVqzT/Lw5O3x4xBNXcyxsP8y2PGGFdlPMx3fnUG02EG7inH/BYZephR4/F4WHn8nMFX7Qe/Xub0hWOL+3Tiw2NLWu+FZv8GGYdtyngv/DD+PGcoMozfnCFXO8uQeiY5hA7bVOpafYgcvpc/zUm1b5BxMrem1aDz9beJ4pepvUzgmn/R+2n1UYYQ1Vj6sIjtCxnVFvJwnn99xuvngc8Zoz4j7wdZ3yJDDjNqkeQd1w4zBvbjdb9/zoivwu/n3nZ6bOs52N1l2zfIOG3TiTa1w/Zg7AcTvz1jHLYH132t8Omx5ZonvKeA6SxD6j5fhE4z6lpfRA77vtRckuhF3yDjsE1xLyg6rsOMuge7Z8cP38vn17fH7+WrrpEfPp9mfe9pPhzX8fC8d1KtTZtP/f4pQ/AVALE2DjPqGfrNeZRxXyfUZ+3DGo+n9qzPe2uvj+l4+rzH0klVOW1PnOP20OefMxjt+fr55hfas5776MM327+QIb0y9PoGGeMwg/FeHsbz54yaP9Z2nfU3bXUvqe31M6wvZCj2Yx72lfh/euzHxtfhse0dj57H4bGNX5a3M+ZpRn1rUuk6PNep5kvvyY/D40KCDD3NwDk2rsPzFGss9OFbGn8h4/BcH+hzQ+kbZJy2h9V74cZvz+iHbcpU5zqzvj1DDtv0s3tSNntzxtN97dNn5bf4tO11djx84+ILGfX06eY8zMCorsyHGfW0Red1nWXMXqP6HIf7MWeNptMO28PQa03Oju28KDPmNeQwo2Ys7ov0cZbRWu1H63qYUV8AnO3wuEx8f2M2PWzTjhuGhycUX8ioJ5yzH57rs+O4PDyJf874ujuXx/UzWLby59f/4/7phx8/fPr+s99n9vsfnvTpww///Ph+//jv33768bO//fV/f8m/+eenDx8/fvjP9798+vnH9//67dN7T/K/e3ft//y9+/+tuDcb//juXfefrznvnxvdP4/4+3uW6z5edv/M8bPxd70P/1n8Z/89d536vH/W+Jmv+++n3D9P/5nusaCT6f2zxc/305T72F33zy124PIduB92+R+09Qf3K67Z/vGHN8H/AQ==", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 915ac59b8e8..8e531d3e5db 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2062 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2068 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2068 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2039 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2074 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2074 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2077 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2077 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2074 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2074 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2077 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2074 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2074 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 423 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 423 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Jump { location: 423 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 428 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 434 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 440 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 446 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 452 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 461 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 467 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 485 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 491 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 498 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 506 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 512 }, Call { location: 2159 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 517 }, Call { location: 2074 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 525 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2074 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2077 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 552 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 556 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 562 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 575 }, Jump { location: 566 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 617 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2077 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 608 }, Jump { location: 586 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 589 }, Jump { location: 598 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 598 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 601 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 607 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 617 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 617 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 620 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 626 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 634 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 653 }, Jump { location: 642 }, JumpIf { condition: Relative(29), location: 644 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 652 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 672 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 663 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 672 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 676 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 682 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 711 }, Jump { location: 703 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 710 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 727 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 718 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2162 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 727 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 734 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 742 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 774 }, Jump { location: 750 }, JumpIf { condition: Relative(29), location: 752 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 760 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2077 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 785 }, JumpIf { condition: Relative(29), location: 776 }, Call { location: 2074 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 784 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 785 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 789 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 795 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 803 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 843 }, Jump { location: 815 }, JumpIf { condition: Relative(29), location: 817 }, Call { location: 2074 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 825 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 831 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1185 }, JumpIf { condition: Relative(29), location: 845 }, Call { location: 2074 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 853 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2077 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 866 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 878 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 891 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 897 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 900 }, Call { location: 2074 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 908 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 914 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 920 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2077 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 940 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2184 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 953 }, Call { location: 2074 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 960 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 966 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 972 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 978 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 984 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2184 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 997 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1003 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1009 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1015 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1021 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1027 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1042 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1048 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1054 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1060 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2276 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1072 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1078 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1084 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1088 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1091 }, Call { location: 2074 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2318 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1104 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1110 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1113 }, Call { location: 2074 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1119 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1125 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1131 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1137 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1143 }, Call { location: 2068 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1146 }, Call { location: 2074 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2387 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1164 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1172 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1178 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1184 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1185 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1193 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1199 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1205 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1213 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1264 }, Jump { location: 1224 }, JumpIf { condition: Relative(22), location: 1226 }, Call { location: 2074 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1234 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1252 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1284 }, JumpIf { condition: Relative(22), location: 1266 }, Call { location: 2074 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1274 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1284 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1292 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1298 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1304 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1312 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1318 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1335 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1341 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1347 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1355 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1406 }, Jump { location: 1366 }, JumpIf { condition: Relative(27), location: 1368 }, Call { location: 2074 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1376 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1394 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1426 }, JumpIf { condition: Relative(27), location: 1408 }, Call { location: 2074 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1416 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2077 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1426 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1434 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1440 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1446 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1454 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1458 }, Jump { location: 1478 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1466 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1478 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1486 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1501 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1507 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1513 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1521 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1527 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1544 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1550 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1556 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1564 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1621 }, Jump { location: 1579 }, JumpIf { condition: Relative(22), location: 1581 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1594 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1609 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1653 }, JumpIf { condition: Relative(22), location: 1623 }, Call { location: 2074 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1641 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1653 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1661 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1678 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1684 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1686 }, Jump { location: 1704 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1692 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1704 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1712 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1743 }, Jump { location: 1725 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1731 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1743 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1751 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1769 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1776 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1779 }, Call { location: 2074 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1793 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1801 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1807 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1815 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1821 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1830 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1837 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1937 }, Jump { location: 1847 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1850 }, Call { location: 2074 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2077 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1863 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1878 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1893 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1899 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1905 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1920 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1928 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1934 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1955 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1943 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1955 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1963 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1980 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1986 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1988 }, Jump { location: 2006 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 1994 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2006 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2021 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2027 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2239 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2038 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2047 }, Call { location: 2071 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2103 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2067 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2081 }, Jump { location: 2083 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2102 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2100 }, 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: 2093 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2102 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2114 }, Jump { location: 2131 }, JumpIf { condition: Direct(32781), location: 2116 }, Jump { location: 2120 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2130 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2130 }, Jump { location: 2143 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2143 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2157 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2157 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2150 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2166 }, Jump { location: 2168 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2183 }, 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: 2180 }, 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: 2173 }, 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: 2183 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2195 }, Jump { location: 2212 }, JumpIf { condition: Direct(32781), location: 2197 }, Jump { location: 2201 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2211 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2211 }, Jump { location: 2224 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2224 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2237 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2230 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2248 }, Jump { location: 2252 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2274 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2273 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2266 }, Jump { location: 2274 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2286 }, Jump { location: 2294 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2317 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2316 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2309 }, Jump { location: 2317 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2329 }, Jump { location: 2346 }, JumpIf { condition: Direct(32782), location: 2331 }, Jump { location: 2335 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2345 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2345 }, Jump { location: 2358 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2358 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2372 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2372 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2365 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2386 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2379 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2396 }, Jump { location: 2402 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2424 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2423 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2416 }, Jump { location: 2424 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2439 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2432 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2073 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2079 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2079 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2050 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2085 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2088 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 434 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 434 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 427 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 433 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 434 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 439 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 445 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 451 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 457 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 463 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 472 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 478 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 496 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 502 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 509 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 517 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 523 }, Call { location: 2170 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 539 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 547 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2088 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 563 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 567 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 573 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 586 }, Jump { location: 577 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 619 }, Jump { location: 597 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 600 }, Jump { location: 609 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 609 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 612 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 618 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 628 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 631 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 637 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 645 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 664 }, Jump { location: 653 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 663 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 683 }, JumpIf { condition: Relative(29), location: 666 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 674 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 683 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 687 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 693 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 722 }, Jump { location: 714 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 721 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 738 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 729 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2173 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 738 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 745 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 753 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 785 }, Jump { location: 761 }, JumpIf { condition: Relative(29), location: 763 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 771 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 796 }, JumpIf { condition: Relative(29), location: 787 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 795 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 796 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 800 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 806 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 814 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 854 }, Jump { location: 826 }, JumpIf { condition: Relative(29), location: 828 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 836 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 842 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1196 }, JumpIf { condition: Relative(29), location: 856 }, Call { location: 2085 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 864 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 877 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 889 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 902 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 908 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 911 }, Call { location: 2085 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 919 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 925 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 931 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 951 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 964 }, Call { location: 2085 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 971 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 977 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 983 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 989 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 995 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1008 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1014 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1020 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1026 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1032 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1038 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1053 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1059 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1065 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1071 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2287 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1083 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1089 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1095 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1099 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1102 }, Call { location: 2085 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2329 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1115 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1121 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1124 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1130 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1136 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1142 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1148 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1154 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1157 }, Call { location: 2085 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2398 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1175 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1183 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1189 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1195 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1196 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1204 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1210 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1216 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1224 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1275 }, Jump { location: 1235 }, JumpIf { condition: Relative(22), location: 1237 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1245 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1263 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1295 }, JumpIf { condition: Relative(22), location: 1277 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1285 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1295 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1303 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1309 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1315 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1323 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1329 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1346 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1352 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1358 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1366 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1417 }, Jump { location: 1377 }, JumpIf { condition: Relative(27), location: 1379 }, Call { location: 2085 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1387 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1405 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1437 }, JumpIf { condition: Relative(27), location: 1419 }, Call { location: 2085 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1427 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1437 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1445 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1451 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1457 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1465 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1469 }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1477 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1497 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1512 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1518 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1524 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1532 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1538 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1555 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1561 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1567 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1575 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1632 }, Jump { location: 1590 }, JumpIf { condition: Relative(22), location: 1592 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1605 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1620 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1664 }, JumpIf { condition: Relative(22), location: 1634 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1652 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1664 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1672 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1689 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1695 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1697 }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1703 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1723 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1754 }, Jump { location: 1736 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1742 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1754 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1762 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1780 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1790 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1798 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1804 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1812 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1818 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1826 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1832 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1841 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1848 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1948 }, Jump { location: 1858 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1861 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1874 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1889 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1904 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1910 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1916 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1931 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1939 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1945 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1966 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1954 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1966 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1974 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1991 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1997 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1999 }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2005 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2032 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2038 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2049 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2058 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2078 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2092 }, Jump { location: 2094 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2113 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2111 }, 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: 2104 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2113 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2125 }, Jump { location: 2142 }, JumpIf { condition: Direct(32781), location: 2127 }, Jump { location: 2131 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2141 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2141 }, Jump { location: 2154 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2154 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2168 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2168 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2161 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2177 }, Jump { location: 2179 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2194 }, 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: 2191 }, 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: 2184 }, 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: 2194 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2206 }, Jump { location: 2223 }, JumpIf { condition: Direct(32781), location: 2208 }, Jump { location: 2212 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2222 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2222 }, Jump { location: 2235 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2235 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2248 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2241 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2259 }, Jump { location: 2263 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2285 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2284 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2277 }, Jump { location: 2285 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2297 }, Jump { location: 2305 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2328 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2327 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2320 }, Jump { location: 2328 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2340 }, Jump { location: 2357 }, JumpIf { condition: Direct(32782), location: 2342 }, Jump { location: 2346 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2356 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2356 }, Jump { location: 2369 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2369 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2383 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2383 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2376 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2397 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2390 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2407 }, Jump { location: 2413 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2435 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2434 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2427 }, Jump { location: 2435 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2450 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2443 }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", From 5e2f39e39ea229c95d3689335803ad24f50f4e1c Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 08:53:34 -0300 Subject: [PATCH 14/41] `simple_reachable_blocks_optimization` is fine --- .../noirc_evaluator/src/ssa/ir/function.rs | 20 +------------- .../opt/remove_unreachable_instructions.rs | 2 +- .../src/ssa/opt/simple_optimization.rs | 27 ++----------------- 3 files changed, 4 insertions(+), 45 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/ir/function.rs b/compiler/noirc_evaluator/src/ssa/ir/function.rs index 7c03b950c65..b6c4296b561 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/function.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/function.rs @@ -1,8 +1,7 @@ -use std::collections::{BTreeSet, VecDeque}; +use std::collections::BTreeSet; use std::sync::Arc; use acvm::FieldElement; -use fxhash::FxHashSet as HashSet; use iter_extended::vecmap; use noirc_frontend::monomorphization::ast::InlineType; use serde::{Deserialize, Serialize}; @@ -193,23 +192,6 @@ impl Function { blocks } - /// Collects all the reachable blocks of this function and returns them in pre-order. - pub(crate) fn reachable_pre_order_blocks(&self) -> Vec { - let mut blocks = Vec::new(); - let mut seen = HashSet::default(); - let mut stack = VecDeque::new(); - stack.push_back(self.entry_block); - - while let Some(block) = stack.pop_front() { - if seen.insert(block) { - blocks.push(block); - stack.extend(self.dfg[block].successors()); - } - } - - blocks - } - pub(crate) fn signature(&self) -> Signature { let params = vecmap(self.parameters(), |param| self.dfg.type_of_value(*param)); let returns = vecmap(self.returns(), |ret| self.dfg.type_of_value(*ret)); diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index d8a232d568d..d785f9ef8b5 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -42,7 +42,7 @@ impl Function { // At the end we'll zero out their terminators. let mut unreachable_blocks = HashSet::default(); - self.simple_reachable_pre_order_blocks_optimization(|context| { + self.simple_reachable_blocks_optimization(|context| { let block_id = context.block_id; if current_block_id != Some(block_id) { diff --git a/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs b/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs index 3091dedc51c..63a9e43099b 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs @@ -34,20 +34,6 @@ impl Function { .expect("`f` cannot error internally so this should be unreachable"); } - /// Similar to `simple_reachable_blocks_optimization` but traverses the blocks in pre-order. - pub(crate) fn simple_reachable_pre_order_blocks_optimization(&mut self, mut f: F) - where - F: FnMut(&mut SimpleOptimizationContext<'_, '_>), - { - let blocks = self.reachable_pre_order_blocks().into_iter(); - - self.simple_optimization_result(blocks, move |context| { - f(context); - Ok(()) - }) - .expect("`f` cannot error internally so this should be unreachable"); - } - /// Performs a simple optimization according to the given callback, returning early if /// an error occurred. /// @@ -62,17 +48,8 @@ impl Function { /// /// `replace_value` can be used to replace a value with another one. This substitution will be /// performed in all subsequent instructions. - pub(crate) fn simple_reachable_blocks_optimization_result(&mut self, f: F) -> RtResult<()> - where - F: FnMut(&mut SimpleOptimizationContext<'_, '_>) -> RtResult<()>, - { - let blocks = self.reachable_blocks().into_iter(); - self.simple_optimization_result(blocks, f) - } - - fn simple_optimization_result( + pub(crate) fn simple_reachable_blocks_optimization_result( &mut self, - blocks: impl Iterator, mut f: F, ) -> RtResult<()> where @@ -80,7 +57,7 @@ impl Function { { let mut values_to_replace = ValueMapping::default(); - for block_id in blocks { + for block_id in self.reachable_blocks() { let instruction_ids = self.dfg[block_id].take_instructions(); self.dfg[block_id].instructions_mut().reserve(instruction_ids.len()); for instruction_id in &instruction_ids { From 4d314ac9277fdeac2f73ccda37783643d0948021 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 08:55:19 -0300 Subject: [PATCH 15/41] add_successors -> add_dominated_blocks --- .../src/ssa/opt/remove_unreachable_instructions.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index d785f9ef8b5..2e9fe792923 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -82,7 +82,7 @@ impl Function { unreachable_blocks.insert(block_id); current_block_instructions_are_unreachable = true; - add_successors(block_id, context.dfg, &mut dom, &mut unreachable_blocks); + add_dominated_blocks(block_id, context.dfg, &mut dom, &mut unreachable_blocks); } }); @@ -97,8 +97,8 @@ impl Function { } } -/// Adds all of a block's successors to the `unreachable_blocks` set if they are dominated by that block. -fn add_successors( +/// Adds all of a block's dominated blocks to the `unreachable_blocks` set if they are dominated by that block. +fn add_dominated_blocks( block_id: BasicBlockId, dfg: &DataFlowGraph, dom: &mut DominatorTree, @@ -106,7 +106,6 @@ fn add_successors( ) { // First compute the set of all successors let mut all_successors = HashSet::default(); - all_successors.insert(block_id); let mut blocks_to_process = vec![block_id]; while let Some(block_id) = blocks_to_process.pop() { From b2b78655b4c9565f15648fa72b7b67553f32880f Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 08:57:05 -0300 Subject: [PATCH 16/41] More renames and comments --- .../src/ssa/opt/remove_unreachable_instructions.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 2e9fe792923..68ddd5a469d 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -104,22 +104,22 @@ fn add_dominated_blocks( dom: &mut DominatorTree, unreachable_blocks: &mut HashSet, ) { - // First compute the set of all successors - let mut all_successors = HashSet::default(); + // First compute the set of all blocks that are reachable from the starting block + let mut reachable_blocks = HashSet::default(); let mut blocks_to_process = vec![block_id]; while let Some(block_id) = blocks_to_process.pop() { for successor in dfg[block_id].successors() { - if all_successors.insert(successor) { + if reachable_blocks.insert(successor) { blocks_to_process.push(successor); } } } // Now add them to `unreachable_blocks` if they are dominated by the block - for successor in all_successors { - if dom.dominates(block_id, successor) { - unreachable_blocks.insert(successor); + for reachable_block in reachable_blocks { + if dom.dominates(block_id, reachable_block) { + unreachable_blocks.insert(reachable_block); } } } From 1375346d1cace2376fd03da6d4d6f4f5f82b8db7 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 08:57:55 -0300 Subject: [PATCH 17/41] Comment --- compiler/noirc_evaluator/src/ssa.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs index dd9f8b74464..8295d3ca381 100644 --- a/compiler/noirc_evaluator/src/ssa.rs +++ b/compiler/noirc_evaluator/src/ssa.rs @@ -213,7 +213,8 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { // Perform another DIE pass to update the used globals after offsetting Brillig indexes. SsaPass::new(Ssa::dead_instruction_elimination, "Dead Instruction Elimination"), SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), - // A function can be potentially unreachable post-DIE if all calls to that function were removed. + // A function can be potentially unreachable post-DIE if all calls to that function were removed, + // or after the removal of unreachable instructions. SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), SsaPass::new(Ssa::checked_to_unchecked, "Checked to unchecked"), SsaPass::new_try( From 763ce42c13a85a102a6fa2b4c10c9ced3301deaa Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 09:04:55 -0300 Subject: [PATCH 18/41] Rename tests --- .../opt/remove_unreachable_instructions.rs | 26 ++++++++++++++----- 1 file changed, 19 insertions(+), 7 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 68ddd5a469d..612a7d941c2 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -199,7 +199,7 @@ mod test { } #[test] - fn removes_unreachable_instructions_from_successors() { + fn removes_unreachable_instructions_from_dominated_blocks_normal_order() { let src = r#" acir(inline) predicate_pure fn main f0 { b0(): @@ -234,7 +234,9 @@ mod test { } #[test] - fn removes_unreachable_instructions_from_successors_goes_in_pre_order() { + fn removes_unreachable_instructions_from_dominated_blocks_different_order() { + // This is the same as `removes_unreachable_instructions_from_dominated_blocks_normal_order` + // except that the blocks are in a different order. let src = r#" acir(inline) predicate_pure fn main f0 { b0(): @@ -269,7 +271,10 @@ mod test { } #[test] - fn removes_unreachable_instructions_if_successor_has_other_predecessors() { + fn removes_unreachable_instructions_from_dominated_blocks_transitively() { + // This tests that if a block has an unreachable instruction, + // all of its successors that are dominated by it are also unreachable, + // and that is applied recursively. let src = r#" acir(inline) predicate_pure fn main f0 { b0(): @@ -306,6 +311,8 @@ mod test { #[test] fn removes_unreachable_instructions_following_block_with_no_instructions() { + // This tests that if a block is determined to be unreachable, + // a dominated block that has no instructions also gets its terminator zeroed out. let src = r#" acir(inline) predicate_pure fn main f0 { b0(): @@ -335,7 +342,8 @@ mod test { } #[test] - fn does_not_zeroes_terminator_of_previously_seen_blocks() { + fn does_not_zeroes_terminator_of_non_dominated_block() { + // Here both b1 and b4 are successors of b3, but both are not dominated by it. let src = r#" acir(inline) predicate_pure fn main f0 { b0(): @@ -359,7 +367,8 @@ mod test { } #[test] - fn does_not_consider_block_as_unreachable_if_it_has_other_predecessors_1() { + fn does_not_zeroes_terminator_of_non_dominated_block_2() { + // Here b3 is a successof of b2 but is not dominated by it. let src = r#" acir(inline) predicate_pure fn main f0 { b0(): @@ -380,7 +389,8 @@ mod test { } #[test] - fn does_not_consider_block_as_unreachable_if_it_has_other_predecessors_2() { + fn does_not_zeroes_terminator_of_non_dominated_block_3() { + // Here b4 is a transitive successor of b2 but is not dominated by it. let src = r#" acir(inline) predicate_pure fn main f0 { b0(): @@ -403,7 +413,9 @@ mod test { } #[test] - fn does_not_consider_block_as_unreachable_if_it_has_other_predecessors_3() { + fn does_not_zeroes_terminator_of_non_dominated_block_4() { + // Here b5 is a transitive successor of b2, but is not dominated by it + // (it's a transitive successof of b1) let src = r#" acir(inline) predicate_pure fn main f0 { b0(): From 9638edb3dbe1405abdd0e3a02caa57cab9f355f3 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 09:28:12 -0300 Subject: [PATCH 19/41] Add an unreachable terminator --- compiler/noirc_evaluator/src/acir/mod.rs | 12 ++++++++++-- .../src/brillig/brillig_gen/brillig_block.rs | 3 +++ .../brillig/brillig_ir/codegen_control_flow.rs | 2 +- .../src/ssa/function_builder/mod.rs | 6 ++++++ .../noirc_evaluator/src/ssa/interpreter/errors.rs | 2 ++ .../noirc_evaluator/src/ssa/interpreter/mod.rs | 3 +++ .../noirc_evaluator/src/ssa/ir/basic_block.rs | 5 +++-- .../noirc_evaluator/src/ssa/ir/instruction.rs | 15 ++++++++++++--- compiler/noirc_evaluator/src/ssa/ir/printer.rs | 3 +++ .../src/ssa/opt/basic_conditional.rs | 3 +++ .../src/ssa/opt/die/prune_dead_parameters.rs | 3 +++ .../noirc_evaluator/src/ssa/opt/flatten_cfg.rs | 4 ++++ compiler/noirc_evaluator/src/ssa/opt/inlining.rs | 1 + compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs | 2 +- .../noirc_evaluator/src/ssa/opt/simplify_cfg.rs | 5 +++++ compiler/noirc_evaluator/src/ssa/opt/unrolling.rs | 4 +++- compiler/noirc_evaluator/src/ssa/parser/ast.rs | 1 + .../noirc_evaluator/src/ssa/parser/into_ssa.rs | 5 ++++- compiler/noirc_evaluator/src/ssa/parser/mod.rs | 12 ++++++++++++ compiler/noirc_evaluator/src/ssa/parser/tests.rs | 11 +++++++++++ compiler/noirc_evaluator/src/ssa/parser/token.rs | 3 +++ 21 files changed, 94 insertions(+), 11 deletions(-) diff --git a/compiler/noirc_evaluator/src/acir/mod.rs b/compiler/noirc_evaluator/src/acir/mod.rs index 7185ab7e619..6c497aaed31 100644 --- a/compiler/noirc_evaluator/src/acir/mod.rs +++ b/compiler/noirc_evaluator/src/acir/mod.rs @@ -913,10 +913,14 @@ impl<'a> Context<'a> { terminator: &TerminatorInstruction, dfg: &DataFlowGraph, ) -> usize { + let no_return_values = Vec::new(); let return_values = match terminator { TerminatorInstruction::Return { return_values, .. } => return_values, + TerminatorInstruction::Unreachable { .. } => &no_return_values, // TODO(https://github.com/noir-lang/noir/issues/4616): Enable recursion on foldable/non-inlined ACIR functions - _ => unreachable!("ICE: Program must have a singular return"), + TerminatorInstruction::JmpIf { .. } | TerminatorInstruction::Jmp { .. } => { + unreachable!("ICE: Program must have a singular return") + } }; return_values @@ -930,12 +934,16 @@ impl<'a> Context<'a> { terminator: &TerminatorInstruction, dfg: &DataFlowGraph, ) -> Result<(Vec, Vec), RuntimeError> { + let no_return_values = Vec::new(); let (return_values, call_stack) = match terminator { TerminatorInstruction::Return { return_values, call_stack } => { (return_values, *call_stack) } // TODO(https://github.com/noir-lang/noir/issues/4616): Enable recursion on foldable/non-inlined ACIR functions - _ => unreachable!("ICE: Program must have a singular return"), + TerminatorInstruction::JmpIf { .. } | TerminatorInstruction::Jmp { .. } => { + unreachable!("ICE: Program must have a singular return") + } + TerminatorInstruction::Unreachable { call_stack } => (&no_return_values, *call_stack), }; let mut has_constant_return = false; diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs index 5f3c17d0405..d2cd5d79a77 100644 --- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs +++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs @@ -251,6 +251,9 @@ impl<'block, Registers: RegisterAllocator> BrilligBlock<'block, Registers> { }); self.brillig_context.codegen_return(&return_registers); } + TerminatorInstruction::Unreachable { .. } => { + self.brillig_context.revert_with_string("Reached the unreachable".to_string()); + } } } diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs index 388c5f7a343..d8a63b8e5ef 100644 --- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs +++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs @@ -277,7 +277,7 @@ impl BrilligContext< }); } - pub(super) fn revert_with_string(&mut self, revert_string: String) { + pub(crate) fn revert_with_string(&mut self, revert_string: String) { if self.can_call_procedures { self.call_revert_with_string_procedure(revert_string); } else { diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs index 7a6aa468ae3..71edf8ba21c 100644 --- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs @@ -442,6 +442,12 @@ impl FunctionBuilder { self.terminate_block_with(TerminatorInstruction::Return { return_values, call_stack }); } + /// Terminate the current block with an unreachable instruction + pub fn terminate_with_unreachable(&mut self) { + let call_stack = self.call_stack; + self.terminate_block_with(TerminatorInstruction::Unreachable { call_stack }); + } + /// Returns a ValueId pointing to the given function or imports the function /// into the current function if it was not already, and returns that ID. pub fn import_function(&mut self, function: FunctionId) -> ValueId { diff --git a/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs b/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs index a0facad28dc..5870c0d4261 100644 --- a/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs +++ b/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs @@ -58,6 +58,8 @@ pub enum InterpreterError { ToRadixFailed { field_id: ValueId, field: FieldElement, radix: u32 }, #[error("Failed to solve blackbox function {name}: {reason}")] BlackBoxError { name: String, reason: String }, + #[error("Reached the unreachable")] + ReachedTheUnreachable, } /// These errors can only result from interpreting malformed SSA diff --git a/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs b/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs index cc842c9fc22..c7e2a47838f 100644 --- a/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs @@ -262,6 +262,9 @@ impl<'ssa> Interpreter<'ssa> { break return_values; } + Some(TerminatorInstruction::Unreachable { .. }) => { + return Err(InterpreterError::ReachedTheUnreachable); + } } }; diff --git a/compiler/noirc_evaluator/src/ssa/ir/basic_block.rs b/compiler/noirc_evaluator/src/ssa/ir/basic_block.rs index 1bfe454ecae..a661da86c37 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/basic_block.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/basic_block.rs @@ -149,8 +149,9 @@ impl BasicBlock { Some(TerminatorInstruction::JmpIf { then_destination, else_destination, .. }) => { vec![*then_destination, *else_destination].into_iter() } - Some(TerminatorInstruction::Return { .. }) => vec![].into_iter(), - None => vec![].into_iter(), + Some(TerminatorInstruction::Return { .. }) + | Some(TerminatorInstruction::Unreachable { .. }) + | None => vec![].into_iter(), } } } diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs index 3ec5711a79a..420d150c7d3 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs @@ -853,6 +853,10 @@ pub(crate) enum TerminatorInstruction { /// as the block arguments. Then the exit block can terminate in a return /// instruction returning these values. Return { return_values: Vec, call_stack: CallStackId }, + + /// A terminator that will never be reached because an instruction in its block + /// will always produce an assertion failure. + Unreachable { call_stack: CallStackId }, } impl TerminatorInstruction { @@ -873,6 +877,7 @@ impl TerminatorInstruction { *return_value = f(*return_value); } } + Unreachable { .. } => (), } } @@ -893,6 +898,7 @@ impl TerminatorInstruction { f(*return_value); } } + Unreachable { .. } => (), } } @@ -913,6 +919,7 @@ impl TerminatorInstruction { f(index, *return_value); } } + Unreachable { .. } => (), } } @@ -927,7 +934,7 @@ impl TerminatorInstruction { Jmp { destination, .. } => { *destination = f(*destination); } - Return { .. } => (), + Return { .. } | Unreachable { .. } => (), } } @@ -935,7 +942,8 @@ impl TerminatorInstruction { match self { TerminatorInstruction::JmpIf { call_stack, .. } | TerminatorInstruction::Jmp { call_stack, .. } - | TerminatorInstruction::Return { call_stack, .. } => *call_stack, + | TerminatorInstruction::Return { call_stack, .. } + | TerminatorInstruction::Unreachable { call_stack } => *call_stack, } } @@ -943,7 +951,8 @@ impl TerminatorInstruction { match self { TerminatorInstruction::JmpIf { call_stack, .. } | TerminatorInstruction::Jmp { call_stack, .. } - | TerminatorInstruction::Return { call_stack, .. } => *call_stack = new_call_stack, + | TerminatorInstruction::Return { call_stack, .. } + | TerminatorInstruction::Unreachable { call_stack } => *call_stack = new_call_stack, } } } diff --git a/compiler/noirc_evaluator/src/ssa/ir/printer.rs b/compiler/noirc_evaluator/src/ssa/ir/printer.rs index 3c19b322a00..fe822cb7382 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/printer.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/printer.rs @@ -157,6 +157,9 @@ fn display_terminator( writeln!(f, " return {}", value_list(dfg, return_values)) } } + Some(TerminatorInstruction::Unreachable { .. }) => { + writeln!(f, " unreachable") + } None => writeln!(f, " (no terminator instruction)"), } } diff --git a/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs b/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs index d09d3dc40c7..c6763754b93 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs @@ -361,6 +361,9 @@ impl Context<'_> { let return_values = vecmap(return_values, |value| self.inserter.resolve(value)); TerminatorInstruction::Return { return_values, call_stack } } + TerminatorInstruction::Unreachable { call_stack } => { + TerminatorInstruction::Unreachable { call_stack } + } }; self.inserter.function.dfg.set_block_terminator(conditional.block_entry, new_terminator); self.inserter.map_data_bus_in_place(); diff --git a/compiler/noirc_evaluator/src/ssa/opt/die/prune_dead_parameters.rs b/compiler/noirc_evaluator/src/ssa/opt/die/prune_dead_parameters.rs index af1c18206d7..e8079a9c654 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/die/prune_dead_parameters.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/die/prune_dead_parameters.rs @@ -128,6 +128,9 @@ impl Function { TerminatorInstruction::Return { .. } => { unreachable!("ICE: A return block should not be a predecessor"); } + TerminatorInstruction::Unreachable { .. } => { + unreachable!("ICE: An unreachable block should not be a predecessor"); + } } } } diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs index ba7b5309e9e..3d9294e4cec 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs @@ -466,6 +466,10 @@ impl<'f> Context<'f> { self.inserter.function.dfg.set_block_terminator(target, new_return); vec![] } + TerminatorInstruction::Unreachable { .. } => { + // Nothing to do + vec![] + } } } diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs index 1f8060f0c3b..1fe660d136a 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs @@ -727,6 +727,7 @@ impl<'function> PerFunctionContext<'function> { Some((block_id, return_values)) } + TerminatorInstruction::Unreachable { .. } => None, // Nothing to do } } } diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs index 7a3b3f143e4..26b64e05c7e 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs @@ -617,7 +617,7 @@ impl<'f> PerFunctionContext<'f> { self.inserter.map_terminator_in_place(block); match self.inserter.function.dfg[block].unwrap_terminator() { - TerminatorInstruction::JmpIf { .. } => (), // Nothing to do + TerminatorInstruction::JmpIf { .. } | TerminatorInstruction::Unreachable { .. } => (), // Nothing to do TerminatorInstruction::Jmp { destination, arguments, .. } => { let destination_parameters = self.inserter.function.dfg[*destination].parameters(); assert_eq!(destination_parameters.len(), arguments.len()); diff --git a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs index cf3697c683a..bd0f0dee8ae 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs @@ -193,6 +193,11 @@ fn check_for_double_jmp(function: &mut Function, block: BasicBlockId, cfg: &mut TerminatorInstruction::Return { .. } => { unreachable!("ICE: predecessor block should not have return terminator instruction") } + TerminatorInstruction::Unreachable { .. } => { + unreachable!( + "ICE: predecessor block should not have unreachable terminator instruction" + ) + } }; function.dfg[predecessor_block].set_terminator(redirected_terminator_instruction); diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs index 4790aad91e6..7926f0110cd 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -914,7 +914,9 @@ impl<'f> LoopIteration<'f> { } vec![*destination] } - TerminatorInstruction::Return { .. } => vec![], + TerminatorInstruction::Return { .. } | TerminatorInstruction::Unreachable { .. } => { + vec![] + } } } diff --git a/compiler/noirc_evaluator/src/ssa/parser/ast.rs b/compiler/noirc_evaluator/src/ssa/parser/ast.rs index 40e53cc4974..3f00a063b1d 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/ast.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/ast.rs @@ -180,6 +180,7 @@ pub(crate) enum ParsedTerminator { Jmp { destination: Identifier, arguments: Vec }, Jmpif { condition: ParsedValue, then_block: Identifier, else_block: Identifier }, Return(Vec), + Unreachable, } #[derive(Debug, Clone)] diff --git a/compiler/noirc_evaluator/src/ssa/parser/into_ssa.rs b/compiler/noirc_evaluator/src/ssa/parser/into_ssa.rs index 18c2e8a0a54..a57aedae027 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/into_ssa.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/into_ssa.rs @@ -229,7 +229,7 @@ impl Translator { queue.push_back(self.lookup_block(then_block)?); queue.push_back(self.lookup_block(else_block)?); } - ParsedTerminator::Return(..) => (), + ParsedTerminator::Return(..) | ParsedTerminator::Unreachable => (), } } @@ -265,6 +265,9 @@ impl Translator { let return_values = self.translate_values(values)?; self.builder.terminate_with_return(return_values); } + ParsedTerminator::Unreachable => { + self.builder.terminate_with_unreachable(); + } } Ok(()) diff --git a/compiler/noirc_evaluator/src/ssa/parser/mod.rs b/compiler/noirc_evaluator/src/ssa/parser/mod.rs index d940bd22a4b..02839147b8e 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/mod.rs @@ -689,6 +689,10 @@ impl<'a> Parser<'a> { return Ok(terminator); } + if let Some(terminator) = self.parse_unreachable()? { + return Ok(terminator); + } + self.expected_instruction_or_terminator() } @@ -742,6 +746,14 @@ impl<'a> Parser<'a> { Ok(Some(ParsedTerminator::Jmpif { condition, then_block, else_block })) } + fn parse_unreachable(&mut self) -> ParseResult> { + if !self.eat_keyword(Keyword::Unreachable)? { + return Ok(None); + } + + Ok(Some(ParsedTerminator::Unreachable)) + } + fn parse_arguments(&mut self) -> ParseResult> { self.eat_or_error(Token::LeftParen)?; let arguments = self.parse_comma_separated_values()?; diff --git a/compiler/noirc_evaluator/src/ssa/parser/tests.rs b/compiler/noirc_evaluator/src/ssa/parser/tests.rs index cf68edd31b5..a7adc24f07e 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/tests.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/tests.rs @@ -259,6 +259,17 @@ fn test_call_no_return_value() { assert_ssa_roundtrip(src); } +#[test] +fn test_unreachable() { + let src = " + acir(inline) fn main f0 { + b0(): + unreachable + } + "; + assert_ssa_roundtrip(src); +} + #[test] fn test_call_intrinsic() { let src = " diff --git a/compiler/noirc_evaluator/src/ssa/parser/token.rs b/compiler/noirc_evaluator/src/ssa/parser/token.rs index dff169c0c5a..987f140dd89 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/token.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/token.rs @@ -172,6 +172,7 @@ pub(crate) enum Keyword { UncheckedAdd, UncheckedSub, UncheckedMul, + Unreachable, Value, Xor, } @@ -238,6 +239,7 @@ impl Keyword { "unchecked_add" => Keyword::UncheckedAdd, "unchecked_sub" => Keyword::UncheckedSub, "unchecked_mul" => Keyword::UncheckedMul, + "unreachable" => Keyword::Unreachable, "value" => Keyword::Value, "xor" => Keyword::Xor, _ => return None, @@ -308,6 +310,7 @@ impl Display for Keyword { Keyword::UncheckedAdd => write!(f, "unchecked_add"), Keyword::UncheckedSub => write!(f, "unchecked_sub"), Keyword::UncheckedMul => write!(f, "unchecked_mul"), + Keyword::Unreachable => write!(f, "unreachable"), Keyword::Value => write!(f, "value"), Keyword::Xor => write!(f, "xor"), } From 426f39028e4443ad0145d1708edbad1627bac509 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 10:36:29 -0300 Subject: [PATCH 20/41] Produce unreachable terminators --- .../opt/remove_unreachable_instructions.rs | 183 +++++++++--------- 1 file changed, 89 insertions(+), 94 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 612a7d941c2..2ff91d6a7ee 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -5,16 +5,16 @@ //! values with zeroed values of the appropriate type. If the block has successors //! those successors will also be considered unreachable if they are dominated //! by that block. -use std::sync::Arc; -use acvm::{AcirField, FieldElement}; use fxhash::FxHashSet as HashSet; -use noirc_errors::call_stack::CallStackId; use crate::ssa::{ ir::{ - basic_block::BasicBlockId, dfg::DataFlowGraph, dom::DominatorTree, function::Function, - instruction::Instruction, types::Type, value::ValueId, + basic_block::BasicBlockId, + dfg::DataFlowGraph, + dom::DominatorTree, + function::Function, + instruction::{Instruction, TerminatorInstruction}, }, ssa_gen::Ssa, }; @@ -38,8 +38,7 @@ impl Function { // Whether the current block instructions were determined to be unreachable let mut current_block_instructions_are_unreachable = false; - // This is the final set of blocks that we concluded have some unreachable instructions. - // At the end we'll zero out their terminators. + // Blocks that can't be reached because their dominator has an always failing instruction. let mut unreachable_blocks = HashSet::default(); self.simple_reachable_blocks_optimization(|context| { @@ -56,7 +55,7 @@ impl Function { } let instruction = context.instruction(); - let is_unreachable = match instruction { + let always_failing_instruction = match instruction { Instruction::Constrain(lhs, rhs, _) => { let Some(lhs_constant) = context.dfg.get_numeric_constant(*lhs) else { return; @@ -78,22 +77,16 @@ impl Function { _ => false, }; - if is_unreachable { - unreachable_blocks.insert(block_id); + if always_failing_instruction { current_block_instructions_are_unreachable = true; add_dominated_blocks(block_id, context.dfg, &mut dom, &mut unreachable_blocks); + let terminator = context.dfg[block_id].take_terminator(); + let call_stack = terminator.call_stack(); + context.dfg[block_id] + .set_terminator(TerminatorInstruction::Unreachable { call_stack }); } }); - - for block_id in unreachable_blocks { - let mut terminator = self.dfg[block_id].take_terminator(); - terminator.map_values_mut(|value_id| { - let typ = self.dfg.type_of_value(value_id); - zeroed_value(self, block_id, &typ) - }); - self.dfg[block_id].set_terminator(terminator); - } } } @@ -124,54 +117,9 @@ fn add_dominated_blocks( } } -fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> ValueId { - match typ { - Type::Numeric(numeric_type) => { - function.dfg.make_constant(FieldElement::zero(), *numeric_type) - } - Type::Array(element_types, len) => { - let mut array = im::Vector::new(); - for _ in 0..*len { - for typ in element_types.iter() { - array.push_back(zeroed_value(function, block_id, typ)); - } - } - let instruction = Instruction::MakeArray { elements: array, typ: typ.clone() }; - let stack = CallStackId::root(); - function.dfg.insert_instruction_and_results(instruction, block_id, None, stack).first() - } - Type::Slice(_) => { - let array = im::Vector::new(); - let instruction = Instruction::MakeArray { elements: array, typ: typ.clone() }; - let stack = CallStackId::root(); - function.dfg.insert_instruction_and_results(instruction, block_id, None, stack).first() - } - Type::Reference(element_type) => { - let instruction = Instruction::Allocate; - let reference_type = Type::Reference(Arc::new((**element_type).clone())); - function - .dfg - .insert_instruction_and_results( - instruction, - block_id, - Some(vec![reference_type]), - CallStackId::root(), - ) - .first() - } - Type::Function => { - // We can have the function return itself. It's fine because the terminator is unreachable anyway. - function.dfg.import_function(function.id()) - } - } -} - #[cfg(test)] mod test { - use crate::{ - assert_ssa_snapshot, - ssa::{opt::assert_normalized_ssa_equals, ssa_gen::Ssa}, - }; + use crate::{assert_ssa_snapshot, ssa::ssa_gen::Ssa}; #[test] fn removes_unreachable_instructions_in_block() { @@ -193,7 +141,7 @@ mod test { b0(): v0 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - return u1 0 + unreachable } "#); } @@ -222,13 +170,9 @@ mod test { assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { b0(): - v2 = make_array [] : [&mut u1; 0] + v0 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - jmp b1(u1 0) - b1(v0: u1): - jmp b2(u1 0) - b2(v1: u1): - return u1 0 + unreachable } "#); } @@ -259,13 +203,9 @@ mod test { assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { b0(): - v2 = make_array [] : [&mut u1; 0] + v0 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - jmp b2(u1 0) - b1(v0: u1): - return u1 0 - b2(v1: u1): - jmp b1(u1 0) + unreachable } "#); } @@ -298,13 +238,7 @@ mod test { acir(inline) predicate_pure fn main f0 { b0(): constrain u1 0 == u1 1, "Index out of bounds" - jmp b1() - b1(): - jmpif u1 0 then: b2, else: b3 - b2(): - jmp b1() - b3(): - return Field 0 + unreachable } "#); } @@ -332,11 +266,7 @@ mod test { acir(inline) predicate_pure fn main f0 { b0(): constrain u1 0 == u1 1, "Index out of bounds" - jmp b1() - b1(): - jmp b2() - b2(): - return Field 0 + unreachable } "#); } @@ -363,7 +293,24 @@ mod test { "#; let ssa = Ssa::from_str(src).unwrap(); let ssa = ssa.remove_unreachable_instructions(); - assert_normalized_ssa_equals(ssa, src); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + jmp b1() + b1(): + v2 = add Field 1, Field 2 + jmp b2(v2) + b2(): + jmpif u1 0 then: b3, else: b4 + b3(): + constrain u1 0 == u1 1, "Index out of bounds" + unreachable + b4(): + v4 = add Field 1, Field 2 + return v4 + } + "#); } #[test] @@ -385,7 +332,21 @@ mod test { "#; let ssa = Ssa::from_str(src).unwrap(); let ssa = ssa.remove_unreachable_instructions(); - assert_normalized_ssa_equals(ssa, src); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + jmp b1() + b1(): + jmpif u1 0 then: b2, else: b3 + b2(): + constrain u1 0 == u1 1, "Index out of bounds" + unreachable + b3(): + v3 = add Field 1, Field 2 + return v3 + } + "#); } #[test] @@ -409,7 +370,23 @@ mod test { "#; let ssa = Ssa::from_str(src).unwrap(); let ssa = ssa.remove_unreachable_instructions(); - assert_normalized_ssa_equals(ssa, src); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + jmp b1() + b1(): + jmpif u1 0 then: b2, else: b3 + b2(): + constrain u1 0 == u1 1, "Index out of bounds" + unreachable + b3(): + jmp b4() + b4(): + v3 = add Field 1, Field 2 + return v3 + } + "#); } #[test] @@ -436,6 +413,24 @@ mod test { "#; let ssa = Ssa::from_str(src).unwrap(); let ssa = ssa.remove_unreachable_instructions(); - assert_normalized_ssa_equals(ssa, src); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + jmp b1() + b1(): + jmpif u1 0 then: b2, else: b3 + b2(): + constrain u1 0 == u1 1, "Index out of bounds" + unreachable + b3(): + jmp b4() + b4(): + jmp b5() + b5(): + v3 = add Field 1, Field 2 + return v3 + } + "#); } } From cd832778f574453f53149f1311a66783b438fac8 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 10:59:05 -0300 Subject: [PATCH 21/41] Assume unreachable can't be reached --- .../noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs | 2 +- .../src/brillig/brillig_ir/codegen_control_flow.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs index d2cd5d79a77..479a4405932 100644 --- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs +++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs @@ -252,7 +252,7 @@ impl<'block, Registers: RegisterAllocator> BrilligBlock<'block, Registers> { self.brillig_context.codegen_return(&return_registers); } TerminatorInstruction::Unreachable { .. } => { - self.brillig_context.revert_with_string("Reached the unreachable".to_string()); + // If we assume this is unreachable code then there's nothing to do here } } } diff --git a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs index d8a63b8e5ef..388c5f7a343 100644 --- a/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs +++ b/compiler/noirc_evaluator/src/brillig/brillig_ir/codegen_control_flow.rs @@ -277,7 +277,7 @@ impl BrilligContext< }); } - pub(crate) fn revert_with_string(&mut self, revert_string: String) { + pub(super) fn revert_with_string(&mut self, revert_string: String) { if self.can_call_procedures { self.call_revert_with_string_procedure(revert_string); } else { From e21e96354bf922da4dfe8354f2a3cda0ab477788 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 11:00:17 -0300 Subject: [PATCH 22/41] Add a test for constrain not equal --- .../opt/remove_unreachable_instructions.rs | 27 ++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 2ff91d6a7ee..f674e9c88cf 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -122,7 +122,7 @@ mod test { use crate::{assert_ssa_snapshot, ssa::ssa_gen::Ssa}; #[test] - fn removes_unreachable_instructions_in_block() { + fn removes_unreachable_instructions_in_block_for_constrain_equal() { let src = r#" acir(inline) predicate_pure fn main f0 { b0(): @@ -146,6 +146,31 @@ mod test { "#); } + #[test] + fn removes_unreachable_instructions_in_block_for_constrain_not_equal() { + let src = r#" + acir(inline) predicate_pure fn main f0 { + b0(): + v0 = make_array [] : [&mut u1; 0] + constrain u1 0 != u1 0, "Index out of bounds" + v4 = array_get v0, index u32 0 -> &mut u1 + v5 = load v4 -> u1 + return v5 + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + v0 = make_array [] : [&mut u1; 0] + constrain u1 0 != u1 0, "Index out of bounds" + unreachable + } + "#); + } + #[test] fn removes_unreachable_instructions_from_dominated_blocks_normal_order() { let src = r#" From 5b7e58b9364834ef6a4445770f5322f45023b69a Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 11:16:52 -0300 Subject: [PATCH 23/41] Snapshots --- ...ests__force_brillig_true_inliner_-9223372036854775808.snap | 4 ++-- .../execute__tests__force_brillig_true_inliner_0.snap | 4 ++-- ...tests__force_brillig_true_inliner_9223372036854775807.snap | 4 ++-- ...ests__force_brillig_true_inliner_-9223372036854775808.snap | 4 ++-- .../execute__tests__force_brillig_true_inliner_0.snap | 4 ++-- ...tests__force_brillig_true_inliner_9223372036854775807.snap | 4 ++-- ...ests__force_brillig_true_inliner_-9223372036854775808.snap | 4 ++-- .../execute__tests__force_brillig_true_inliner_0.snap | 4 ++-- ...tests__force_brillig_true_inliner_9223372036854775807.snap | 4 ++-- ...sts__force_brillig_false_inliner_-9223372036854775808.snap | 4 ++-- .../execute__tests__force_brillig_false_inliner_0.snap | 4 ++-- ...ests__force_brillig_false_inliner_9223372036854775807.snap | 4 ++-- ...ests__force_brillig_true_inliner_-9223372036854775808.snap | 4 ++-- .../execute__tests__force_brillig_true_inliner_0.snap | 4 ++-- ...tests__force_brillig_true_inliner_9223372036854775807.snap | 4 ++-- ...ests__force_brillig_true_inliner_-9223372036854775808.snap | 4 ++-- .../execute__tests__force_brillig_true_inliner_0.snap | 4 ++-- ...tests__force_brillig_true_inliner_9223372036854775807.snap | 4 ++-- ...ests__force_brillig_true_inliner_-9223372036854775808.snap | 4 ++-- .../execute__tests__force_brillig_true_inliner_0.snap | 4 ++-- ...tests__force_brillig_true_inliner_9223372036854775807.snap | 4 ++-- ...ests__force_brillig_true_inliner_-9223372036854775808.snap | 4 ++-- .../execute__tests__force_brillig_true_inliner_0.snap | 4 ++-- ...tests__force_brillig_true_inliner_9223372036854775807.snap | 4 ++-- 24 files changed, 48 insertions(+), 48 deletions(-) diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 4e0735204b7..4573d95bc87 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -88,9 +88,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 393 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 319 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Direct(32838) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(8) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(7), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 180 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 190 }, Jump { location: 184 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(7), rhs: Relative(1) }, JumpIf { condition: Relative(8), location: 189 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(7), location: 206 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, JumpIf { condition: Relative(5), location: 214 }, Jump { location: 211 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(7), source: Relative(1) }, Jump { location: 226 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 226 }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 233 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 240 }, Call { location: 479 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(7), location: 256 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(5), location: 264 }, Jump { location: 261 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(7) }, JumpIf { condition: Relative(5), location: 277 }, Jump { location: 274 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 279 }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 285 }, Jump { location: 287 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 287 }, Load { destination: Relative(4), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 292 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 306 }, Jump { location: 300 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 305 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 313 }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Store { destination_pointer: Relative(1), source: Relative(4) }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 322 }, Jump { location: 328 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 324 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 331 }, Jump { location: 327 }, Jump { location: 328 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 335 }, Call { location: 482 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 340 }, Call { location: 485 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 343 }, Call { location: 488 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 350 }, Call { location: 488 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 457 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 360 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 380 }, Jump { location: 363 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 367 }, Jump { location: 377 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 377 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 324 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 389 }, Call { location: 482 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 360 }, 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: 398 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 393 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 405 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 410 }, Jump { location: 408 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 412 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 418 }, Jump { location: 415 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 405 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 425 }, Call { location: 488 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 431 }, Jump { location: 454 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 454 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 412 }, 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: 461 }, Jump { location: 463 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 478 }, 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: 475 }, 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: 468 }, 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: 478 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 392 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 318 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Direct(32838) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(8) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(7), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 180 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 189 }, Jump { location: 184 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 189 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Load { destination: Relative(7), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 198 }, Load { destination: Relative(7), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(7), location: 205 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, JumpIf { condition: Relative(5), location: 213 }, Jump { location: 210 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(7), source: Relative(1) }, Jump { location: 225 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 225 }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 232 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 239 }, Call { location: 478 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(7), location: 255 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(5), location: 263 }, Jump { location: 260 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 278 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(7) }, JumpIf { condition: Relative(5), location: 276 }, Jump { location: 273 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 278 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 278 }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 284 }, Jump { location: 286 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 286 }, Load { destination: Relative(4), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 291 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 296 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 305 }, Jump { location: 299 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 304 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 312 }, Jump { location: 315 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Store { destination_pointer: Relative(1), source: Relative(4) }, Jump { location: 315 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 296 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 321 }, Jump { location: 327 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 323 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 330 }, Jump { location: 326 }, Jump { location: 327 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 334 }, Call { location: 481 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 339 }, Call { location: 484 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 342 }, Call { location: 487 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 349 }, Call { location: 487 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 456 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 359 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 379 }, Jump { location: 362 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 366 }, Jump { location: 376 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 376 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 323 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 388 }, Call { location: 481 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 359 }, 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: 397 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 392 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 404 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 409 }, Jump { location: 407 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 411 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 417 }, Jump { location: 414 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 404 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 424 }, Call { location: 487 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 430 }, Jump { location: 453 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 453 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 411 }, 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: 460 }, Jump { location: 462 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 477 }, 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: 474 }, 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: 467 }, 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: 477 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZnNTmM5EIXfJess/Fcuu18FtVoBQitSFFAaRhoh3n18ruvcCwtGrcqG8yWhzi2Xyz+E993j8f7t96/T5en5z+7H3fvu/no6n0+/f52fHw6vp+fLePd9F/AjxiFxPzSaJtNsWkzFtJqqaTPtU5P5JfNL5pfML5lfMr9kfsn8kvkl88vj9xJ0vJ+h4/0ytATT8RyBJtNsWkzFdDynQtW0mfapEkyjaTIdfgotpmJaTdW0mfapNZhG02RqftX8qvlV86vDr0GbaZ+qwTSaJtNsOvw6VExR1wBQQiN0g4a5QpEbJgXVbUKoBCU0g44olL5jilHbngiZUAhCqAQlII1R4hRgqIBIgGEDZEIhCAGGHaCEZoBeTgGQCCM8JYAQKkEJjdAN0MsTIgGGGZAJhVDtWejkVACNAMMx5JQDIRISIRMKQQiVoIRGoHOhc6EzFkRCebEiJhSCECpBCY3QDbAwEiYFK2MCnDEFWBsTCkEIcMZcYH1MaAZYERmFwpKYMMJzBAihEpTQCN0AK2JCJMAH04RFMAHhmB30fMZcoOcz6tMiAWlgpGj+jAGi5yfgoRhO6wZo/gmRgHCMC80/YaRRMC60ehmJZXR4SYARVTIgETKhECqjEF4AjdANsGsXAWRzRodPqAT88hhXRosWBcw9NKP7SgMkQiYUghDg1wFKaIRusGzGC0RCImA/DoBCEEIlKKERugG6T1AMdN+ERMiEQhBCJagBtmNBVbD/CoqAphPUEi02oRH6rNPSYdBomkyzaTEVU53a+DD02AQkjflqmVAIYglhy52ghEboBmg/QEFHSQVEQiLAUAEIH1NYsA1KBwjfaXwHx98odMFeNyESEiETCmH41AioBCXgXB1DLmiyCfBBzmiyCYUAnwKoBCXARwDdAE02IRISIRMKgSNdmmwBJbAsS5MBliZbIBISAdPUPj72O96dfr1ej0dcnT5dpsYV6+VwPV5edz8ub+fzfvfP4fy2/NKfl8Nl0dfDdXw6ine8PA4dhk+n8xH0sd+iw/ehJagFj2lcw+Xv4zGeGV+DI14zk9dcHPEtML6Fdlt8zJ74xPq17Klfx/GxxHdfPK4mFq+eeOH4u5Qb47snXtd4rY74GHC6LQYxyLcdENP3FkmTOSRtrhTWOYghBZ9DWh2iqwwRm/R0GJd8l0Nrq0NPNzt4mnH8ecfVNNA1iryux4EuhyRbDvrtKFL8vyRwZlkSn7o69r9Pom8OwdVSWdaWGum4HIre6qBbDtpdDn1z6PVGh3Gr8TiUvLb1uDZ4HGrkJj9QXDng+mE5VFcOsm0x4jrpxncVax2k+OqQ1xxqdi3OKlsl5WaH6qpD1bUO1dfVta8OGjyn7vheZl2bWlx1UNly8NVB27pHaXMdGC2tc9Gya3W3bV00da1u7evB2Xw77RcHz+qWwDJI9HSDFE6EFM88SOUAxFVDUTajtOqKlzVeXfmv41fP+Ot666iuS0ctrJ9vT6qdz9fgGX+VeNPzb70Ayzp9vjW8bmXd033a1z8APX9/tO3q7rq5r/tP6Lc93nc/qtvlxncarkeZ71axHYVfy/dzvDo8nK5f/jn0Aafr6XB/PtrLp7fLw6dPX/994Sf859LL9fnh+Ph2PcJp+w/T+HFXxk29aPs5vsEar3rYxxDGC3yLeZd73ueOz/C1/V1psi9Nf34gs/8A", + "debug_symbols": "pZnLTiNJEEX/xWsW+Yp89K8ghAyYliXLIDeMNEL8+8StjFsFC0at8Mb3uOy4lRkZ+XD5Y/d0eHj/fX88P7/82f26/dg9XI6n0/H3/enlcf92fDnr1Y9dwEuMKvFGNZom02xaTMW0mjbTbjqmJvNL5pfML5lfMr9kfsn8kvkl80vml/V7CarXM1SvF9USTPU+Ak2m2bSYiqnep0KbaTcdUyWYRtNkqn4NWkzFtJo20246ptZgGk2TqflV86vmV82vql+HdtMxtQXTaJpMs6n6DaiYIq8B0AidMAw6xgpJ7hgUZLcLoRIaoRMQjtQPhCO3IxISIRMKQQiVAEOkeMBQ+55CIMCwAxIhEwoBhgNQCc0ANZ0CIBI0PCVAIQihEhqhE4YBinoCDDMgETJB7F6o6FQAjQBDAQyDHAiRkAiZUAhCqIRGoHOmc6EzJkaqgETIhEIQQiU0QifAGYOCGTIBzhgCzJEJmVAIcMZYYJ5MaAaYGRmJwtSYoOE5AgpBCJXQCJ0wDDA1JsAHw4TJMAHhGB0Uf8ZYoPgz8oPin4BmoKeYBRkdRPFPwE3RHRT/hGGA4p+AcPQLxT9Bm1HQL5R6QcNQ4UXbk1HhJQMiIREyQWZURmGXAmiEToChNj5juV6cUeEThIAva78ySrQ0QFvW0IzqKx0QCYmQCYUAvwGohEbohGGwrMoLRALW5QDIhEIQQiU0QieosyAZqL4JkZAImVAIQqgE+CArWIcFSUDRCXKJEpvQCHOvyUuFqS4FBo2myTSbFtNqypuhxiag0RivngiZUKxBWHsnVEIjdMIwQEWJDm5BRU2IBBg2AMJ1CAuWQRmAwiuNV7ANBsAwwFo3IRISIRPUp0aAECoB+6t2uaDIJsAnAxIhE+BTAEKoBPgIoBOGAYpsQiQkQiawp0uRLVAJTMtSZAsMg6XIFogEDFP//LzZ8ex0/3Y5HHB0+nKY0iPW6/5yOL/tfp3fT6eb3T/70/vypT+v+/Oib/uLfqrJO5yfVNXw+Xg6gD5vtujwc6gOpwWXKGu4/H08+jPja3DEt8zGt1wc8T0wvod+XXzMnvjE/PXsyd/A9rHED188jiYW3zzxwv4PKVfGD098W+NbdcTHgN1tMYhBfqyAmH62SC2Zg+7nriasYxBDCj6HtDpEVxoiFunpoId8l0Pvq8NIVzt4ilF/3nE2Kbp6kdf5qOhySLK1of3YixT/rxHYs6wRX6o6jr9vxNgcgquksqwlpc1xOZR2rUPb2tCGy2FsDqNe6aCHGY9DyWtZ62nB41AjF3lFcbUBxw9rQ3W1QbYlRlw7nT6rWPMgxZeHvLahZtfkrLJlUq52qK481Lbmofqquo7VoQXPrqvPZda52YorD022Nvjy0Pq6RrXu2jB6WseiZ9fs7tu86M01u9tYN87uW2m/OXhmtwSmQaKnGqRwIKR4xkEqOyCuHEpjMUqvrnhZ45ur/Wv/m6f/dT11VNehoxbmz7cm1cH7t+Dpf5V41f2vPQDLOny+ObwuZcNTfW2sPwA9vz/6dnR3ndzX9SeM627vOx/V7XDj2w3Xrcx3qti2wu/pu9N3+8fj5dufQ59wuhz3D6eDvX1+Pz9++fTt31d+wj+XXi8vj4en98sBTts/TPpyW/Q3T2ntTh9c6bsRbmII+gbP6W9x7MsDn+Ex1W3p5ab0eveJlv0H", "file_map": { "19": { "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap index 4e0735204b7..4573d95bc87 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap @@ -88,9 +88,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 393 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 319 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Direct(32838) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(8) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(7), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 180 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 190 }, Jump { location: 184 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(7), rhs: Relative(1) }, JumpIf { condition: Relative(8), location: 189 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(7), location: 206 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, JumpIf { condition: Relative(5), location: 214 }, Jump { location: 211 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(7), source: Relative(1) }, Jump { location: 226 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 226 }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 233 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 240 }, Call { location: 479 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(7), location: 256 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(5), location: 264 }, Jump { location: 261 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(7) }, JumpIf { condition: Relative(5), location: 277 }, Jump { location: 274 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 279 }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 285 }, Jump { location: 287 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 287 }, Load { destination: Relative(4), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 292 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 306 }, Jump { location: 300 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 305 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 313 }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Store { destination_pointer: Relative(1), source: Relative(4) }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 322 }, Jump { location: 328 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 324 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 331 }, Jump { location: 327 }, Jump { location: 328 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 335 }, Call { location: 482 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 340 }, Call { location: 485 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 343 }, Call { location: 488 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 350 }, Call { location: 488 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 457 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 360 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 380 }, Jump { location: 363 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 367 }, Jump { location: 377 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 377 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 324 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 389 }, Call { location: 482 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 360 }, 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: 398 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 393 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 405 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 410 }, Jump { location: 408 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 412 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 418 }, Jump { location: 415 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 405 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 425 }, Call { location: 488 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 431 }, Jump { location: 454 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 454 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 412 }, 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: 461 }, Jump { location: 463 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 478 }, 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: 475 }, 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: 468 }, 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: 478 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 392 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 318 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Direct(32838) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(8) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(7), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 180 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 189 }, Jump { location: 184 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 189 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Load { destination: Relative(7), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 198 }, Load { destination: Relative(7), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(7), location: 205 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, JumpIf { condition: Relative(5), location: 213 }, Jump { location: 210 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(7), source: Relative(1) }, Jump { location: 225 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 225 }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 232 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 239 }, Call { location: 478 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(7), location: 255 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(5), location: 263 }, Jump { location: 260 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 278 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(7) }, JumpIf { condition: Relative(5), location: 276 }, Jump { location: 273 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 278 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 278 }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 284 }, Jump { location: 286 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 286 }, Load { destination: Relative(4), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 291 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 296 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 305 }, Jump { location: 299 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 304 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 312 }, Jump { location: 315 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Store { destination_pointer: Relative(1), source: Relative(4) }, Jump { location: 315 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 296 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 321 }, Jump { location: 327 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 323 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 330 }, Jump { location: 326 }, Jump { location: 327 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 334 }, Call { location: 481 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 339 }, Call { location: 484 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 342 }, Call { location: 487 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 349 }, Call { location: 487 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 456 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 359 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 379 }, Jump { location: 362 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 366 }, Jump { location: 376 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 376 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 323 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 388 }, Call { location: 481 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 359 }, 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: 397 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 392 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 404 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 409 }, Jump { location: 407 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 411 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 417 }, Jump { location: 414 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 404 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 424 }, Call { location: 487 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 430 }, Jump { location: 453 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 453 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 411 }, 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: 460 }, Jump { location: 462 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 477 }, 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: 474 }, 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: 467 }, 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: 477 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZnNTmM5EIXfJess/Fcuu18FtVoBQitSFFAaRhoh3n18ruvcCwtGrcqG8yWhzi2Xyz+E993j8f7t96/T5en5z+7H3fvu/no6n0+/f52fHw6vp+fLePd9F/AjxiFxPzSaJtNsWkzFtJqqaTPtU5P5JfNL5pfML5lfMr9kfsn8kvkl88vj9xJ0vJ+h4/0ytATT8RyBJtNsWkzFdDynQtW0mfapEkyjaTIdfgotpmJaTdW0mfapNZhG02RqftX8qvlV86vDr0GbaZ+qwTSaJtNsOvw6VExR1wBQQiN0g4a5QpEbJgXVbUKoBCU0g44olL5jilHbngiZUAhCqAQlII1R4hRgqIBIgGEDZEIhCAGGHaCEZoBeTgGQCCM8JYAQKkEJjdAN0MsTIgGGGZAJhVDtWejkVACNAMMx5JQDIRISIRMKQQiVoIRGoHOhc6EzFkRCebEiJhSCECpBCY3QDbAwEiYFK2MCnDEFWBsTCkEIcMZcYH1MaAZYERmFwpKYMMJzBAihEpTQCN0AK2JCJMAH04RFMAHhmB30fMZcoOcz6tMiAWlgpGj+jAGi5yfgoRhO6wZo/gmRgHCMC80/YaRRMC60ehmJZXR4SYARVTIgETKhECqjEF4AjdANsGsXAWRzRodPqAT88hhXRosWBcw9NKP7SgMkQiYUghDg1wFKaIRusGzGC0RCImA/DoBCEEIlKKERugG6T1AMdN+ERMiEQhBCJagBtmNBVbD/CoqAphPUEi02oRH6rNPSYdBomkyzaTEVU53a+DD02AQkjflqmVAIYglhy52ghEboBmg/QEFHSQVEQiLAUAEIH1NYsA1KBwjfaXwHx98odMFeNyESEiETCmH41AioBCXgXB1DLmiyCfBBzmiyCYUAnwKoBCXARwDdAE02IRISIRMKgSNdmmwBJbAsS5MBliZbIBISAdPUPj72O96dfr1ej0dcnT5dpsYV6+VwPV5edz8ub+fzfvfP4fy2/NKfl8Nl0dfDdXw6ine8PA4dhk+n8xH0sd+iw/ehJagFj2lcw+Xv4zGeGV+DI14zk9dcHPEtML6Fdlt8zJ74xPq17Klfx/GxxHdfPK4mFq+eeOH4u5Qb47snXtd4rY74GHC6LQYxyLcdENP3FkmTOSRtrhTWOYghBZ9DWh2iqwwRm/R0GJd8l0Nrq0NPNzt4mnH8ecfVNNA1iryux4EuhyRbDvrtKFL8vyRwZlkSn7o69r9Pom8OwdVSWdaWGum4HIre6qBbDtpdDn1z6PVGh3Gr8TiUvLb1uDZ4HGrkJj9QXDng+mE5VFcOsm0x4jrpxncVax2k+OqQ1xxqdi3OKlsl5WaH6qpD1bUO1dfVta8OGjyn7vheZl2bWlx1UNly8NVB27pHaXMdGC2tc9Gya3W3bV00da1u7evB2Xw77RcHz+qWwDJI9HSDFE6EFM88SOUAxFVDUTajtOqKlzVeXfmv41fP+Ot666iuS0ctrJ9vT6qdz9fgGX+VeNPzb70Ayzp9vjW8bmXd033a1z8APX9/tO3q7rq5r/tP6Lc93nc/qtvlxncarkeZ71axHYVfy/dzvDo8nK5f/jn0Aafr6XB/PtrLp7fLw6dPX/994Sf859LL9fnh+Ph2PcJp+w/T+HFXxk29aPs5vsEar3rYxxDGC3yLeZd73ueOz/C1/V1psi9Nf34gs/8A", + "debug_symbols": "pZnLTiNJEEX/xWsW+Yp89K8ghAyYliXLIDeMNEL8+8StjFsFC0at8Mb3uOy4lRkZ+XD5Y/d0eHj/fX88P7/82f26/dg9XI6n0/H3/enlcf92fDnr1Y9dwEuMKvFGNZom02xaTMW0mjbTbjqmJvNL5pfML5lfMr9kfsn8kvkl80vml/V7CarXM1SvF9USTPU+Ak2m2bSYiqnep0KbaTcdUyWYRtNkqn4NWkzFtJo20246ptZgGk2TqflV86vmV82vql+HdtMxtQXTaJpMs6n6DaiYIq8B0AidMAw6xgpJ7hgUZLcLoRIaoRMQjtQPhCO3IxISIRMKQQiVAEOkeMBQ+55CIMCwAxIhEwoBhgNQCc0ANZ0CIBI0PCVAIQihEhqhE4YBinoCDDMgETJB7F6o6FQAjQBDAQyDHAiRkAiZUAhCqIRGoHOmc6EzJkaqgETIhEIQQiU0QifAGYOCGTIBzhgCzJEJmVAIcMZYYJ5MaAaYGRmJwtSYoOE5AgpBCJXQCJ0wDDA1JsAHw4TJMAHhGB0Uf8ZYoPgz8oPin4BmoKeYBRkdRPFPwE3RHRT/hGGA4p+AcPQLxT9Bm1HQL5R6QcNQ4UXbk1HhJQMiIREyQWZURmGXAmiEToChNj5juV6cUeEThIAva78ySrQ0QFvW0IzqKx0QCYmQCYUAvwGohEbohGGwrMoLRALW5QDIhEIQQiU0QieosyAZqL4JkZAImVAIQqgE+CArWIcFSUDRCXKJEpvQCHOvyUuFqS4FBo2myTSbFtNqypuhxiag0RivngiZUKxBWHsnVEIjdMIwQEWJDm5BRU2IBBg2AMJ1CAuWQRmAwiuNV7ANBsAwwFo3IRISIRPUp0aAECoB+6t2uaDIJsAnAxIhE+BTAEKoBPgIoBOGAYpsQiQkQiawp0uRLVAJTMtSZAsMg6XIFogEDFP//LzZ8ex0/3Y5HHB0+nKY0iPW6/5yOL/tfp3fT6eb3T/70/vypT+v+/Oib/uLfqrJO5yfVNXw+Xg6gD5vtujwc6gOpwWXKGu4/H08+jPja3DEt8zGt1wc8T0wvod+XXzMnvjE/PXsyd/A9rHED188jiYW3zzxwv4PKVfGD098W+NbdcTHgN1tMYhBfqyAmH62SC2Zg+7nriasYxBDCj6HtDpEVxoiFunpoId8l0Pvq8NIVzt4ilF/3nE2Kbp6kdf5qOhySLK1of3YixT/rxHYs6wRX6o6jr9vxNgcgquksqwlpc1xOZR2rUPb2tCGy2FsDqNe6aCHGY9DyWtZ62nB41AjF3lFcbUBxw9rQ3W1QbYlRlw7nT6rWPMgxZeHvLahZtfkrLJlUq52qK481Lbmofqquo7VoQXPrqvPZda52YorD022Nvjy0Pq6RrXu2jB6WseiZ9fs7tu86M01u9tYN87uW2m/OXhmtwSmQaKnGqRwIKR4xkEqOyCuHEpjMUqvrnhZ45ur/Wv/m6f/dT11VNehoxbmz7cm1cH7t+Dpf5V41f2vPQDLOny+ObwuZcNTfW2sPwA9vz/6dnR3ndzX9SeM627vOx/V7XDj2w3Xrcx3qti2wu/pu9N3+8fj5dufQ59wuhz3D6eDvX1+Pz9++fTt31d+wj+XXi8vj4en98sBTts/TPpyW/Q3T2ntTh9c6bsRbmII+gbP6W9x7MsDn+Ex1W3p5ab0eveJlv0H", "file_map": { "19": { "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 3609e99d16d..411bd34352c 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -88,9 +88,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 491 }, 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(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 121 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 115 }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(13), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Relative(2) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(15), location: 417 }, Jump { location: 138 }, Load { destination: Relative(14), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(9) }, Load { destination: Relative(8), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 145 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Load { destination: Relative(8), source_pointer: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(7) }, JumpIf { condition: Relative(8), location: 153 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, 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(14), source: Relative(9) }, Store { destination_pointer: Relative(14), source: Relative(10) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(7) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(8) }, Mov { destination: Relative(5), source: Relative(10) }, Jump { location: 172 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(8), location: 370 }, Jump { location: 175 }, Load { destination: Relative(5), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Load { destination: Relative(8), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 182 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 192 }, Jump { location: 186 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(9), location: 191 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Jump { location: 201 }, Load { destination: Relative(8), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(10) }, Store { destination_pointer: Relative(14), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Jump { location: 201 }, Load { destination: Relative(8), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, JumpIf { condition: Relative(8), location: 208 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, JumpIf { condition: Relative(5), location: 216 }, Jump { location: 213 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(8), source: Relative(1) }, Jump { location: 228 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(9), size: Relative(14) }, output: HeapArray { pointer: Relative(15), size: 32 } }), BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Store { destination_pointer: Relative(8), source: Relative(3) }, Jump { location: 228 }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Load { destination: Relative(8), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(3), rhs: Relative(8) }, JumpIf { condition: Relative(4), location: 235 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(3), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 242 }, Call { location: 519 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, 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: Relative(3) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 249 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 323 }, Jump { location: 252 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 260 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, JumpIf { condition: Relative(5), location: 268 }, Jump { location: 265 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 283 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Store { destination_pointer: Relative(9), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, JumpIf { condition: Relative(5), location: 281 }, Jump { location: 278 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 283 }, Store { destination_pointer: Relative(3), source: Relative(7) }, Jump { location: 283 }, Load { destination: Relative(1), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 289 }, Jump { location: 291 }, Store { destination_pointer: Relative(3), source: Relative(11) }, Jump { location: 291 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, JumpIf { condition: Relative(3), location: 296 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 301 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 310 }, Jump { location: 304 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 309 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, 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(5), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 317 }, Jump { location: 320 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(7) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 320 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 301 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 325 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(8), location: 331 }, Jump { location: 328 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 249 }, Load { destination: Relative(8), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 338 }, Call { location: 522 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Load { destination: Relative(14), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(14) }, JumpIf { condition: Relative(8), location: 344 }, Jump { location: 367 }, Load { destination: Relative(8), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Store { destination_pointer: Relative(17), source: Relative(14) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Store { destination_pointer: Relative(16), source: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(8) }, Jump { location: 367 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Mov { destination: Relative(3), source: Relative(8) }, Jump { location: 325 }, Mov { destination: Relative(8), source: Relative(2) }, Jump { location: 372 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, JumpIf { condition: Relative(14), location: 378 }, Jump { location: 375 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(8) }, Jump { location: 172 }, Load { destination: Relative(14), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 385 }, Call { location: 522 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(8) }, Load { destination: Relative(16), source_pointer: Relative(18) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(16) }, JumpIf { condition: Relative(14), location: 391 }, Jump { location: 414 }, Load { destination: Relative(14), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(8) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Store { destination_pointer: Relative(18), source: Relative(15) }, Store { destination_pointer: Relative(9), source: Relative(14) }, Jump { location: 414 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 372 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 420 }, Jump { location: 426 }, Mov { destination: Relative(15), source: Relative(2) }, Jump { location: 422 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 429 }, Jump { location: 425 }, Jump { location: 426 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(15) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 433 }, Call { location: 525 }, Load { destination: Relative(18), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 438 }, Call { location: 528 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(19), rhs: Relative(12) }, JumpIf { condition: Relative(20), location: 441 }, Call { location: 522 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(19) }, Load { destination: Relative(20), source_pointer: Relative(22) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(9) }, JumpIf { condition: Relative(19), location: 448 }, Call { location: 522 }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 497 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(20) }, Store { destination_pointer: Relative(8), source: Relative(19) }, Mov { destination: Relative(16), source: Relative(2) }, Jump { location: 458 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, JumpIf { condition: Relative(17), location: 478 }, Jump { location: 461 }, Load { destination: Relative(16), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, JumpIf { condition: Relative(17), location: 465 }, Jump { location: 475 }, Load { destination: Relative(16), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Store { destination_pointer: Relative(6), source: Relative(18) }, Jump { location: 475 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Mov { destination: Relative(15), source: Relative(16) }, Jump { location: 422 }, Load { destination: Relative(17), source_pointer: Relative(7) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(16) }, Load { destination: Relative(19), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(17), rhs: Relative(18) }, JumpIf { condition: Relative(20), location: 487 }, Call { location: 525 }, Store { destination_pointer: Relative(7), source: Relative(18) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Mov { destination: Relative(16), source: Relative(17) }, Jump { location: 458 }, 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: 496 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, 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: 501 }, Jump { location: 503 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 518 }, 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: 515 }, 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: 508 }, 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: 518 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 490 }, 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(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 121 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 115 }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(13), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Relative(2) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(15), location: 416 }, Jump { location: 138 }, Load { destination: Relative(14), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(9) }, Load { destination: Relative(8), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 145 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Load { destination: Relative(8), source_pointer: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(7) }, JumpIf { condition: Relative(8), location: 153 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, 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(14), source: Relative(9) }, Store { destination_pointer: Relative(14), source: Relative(10) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(7) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(8) }, Mov { destination: Relative(5), source: Relative(10) }, Jump { location: 172 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(8), location: 369 }, Jump { location: 175 }, Load { destination: Relative(5), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Load { destination: Relative(8), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 182 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 191 }, Jump { location: 186 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 191 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Load { destination: Relative(8), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(10) }, Store { destination_pointer: Relative(14), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Jump { location: 200 }, Load { destination: Relative(8), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, JumpIf { condition: Relative(8), location: 207 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, JumpIf { condition: Relative(5), location: 215 }, Jump { location: 212 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(8), source: Relative(1) }, Jump { location: 227 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(9), size: Relative(14) }, output: HeapArray { pointer: Relative(15), size: 32 } }), BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Store { destination_pointer: Relative(8), source: Relative(3) }, Jump { location: 227 }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Load { destination: Relative(8), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(3), rhs: Relative(8) }, JumpIf { condition: Relative(4), location: 234 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(3), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 241 }, Call { location: 518 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, 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: Relative(3) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 248 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 322 }, Jump { location: 251 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 259 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, JumpIf { condition: Relative(5), location: 267 }, Jump { location: 264 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 282 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Store { destination_pointer: Relative(9), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, JumpIf { condition: Relative(5), location: 280 }, Jump { location: 277 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 282 }, Store { destination_pointer: Relative(3), source: Relative(7) }, Jump { location: 282 }, Load { destination: Relative(1), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 288 }, Jump { location: 290 }, Store { destination_pointer: Relative(3), source: Relative(11) }, Jump { location: 290 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, JumpIf { condition: Relative(3), location: 295 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 300 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 309 }, Jump { location: 303 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 308 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, 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(5), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 316 }, Jump { location: 319 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(7) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 319 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 300 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 324 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(8), location: 330 }, Jump { location: 327 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 248 }, Load { destination: Relative(8), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 337 }, Call { location: 521 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Load { destination: Relative(14), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(14) }, JumpIf { condition: Relative(8), location: 343 }, Jump { location: 366 }, Load { destination: Relative(8), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Store { destination_pointer: Relative(17), source: Relative(14) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Store { destination_pointer: Relative(16), source: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(8) }, Jump { location: 366 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Mov { destination: Relative(3), source: Relative(8) }, Jump { location: 324 }, Mov { destination: Relative(8), source: Relative(2) }, Jump { location: 371 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, JumpIf { condition: Relative(14), location: 377 }, Jump { location: 374 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(8) }, Jump { location: 172 }, Load { destination: Relative(14), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 384 }, Call { location: 521 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(8) }, Load { destination: Relative(16), source_pointer: Relative(18) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(16) }, JumpIf { condition: Relative(14), location: 390 }, Jump { location: 413 }, Load { destination: Relative(14), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(8) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Store { destination_pointer: Relative(18), source: Relative(15) }, Store { destination_pointer: Relative(9), source: Relative(14) }, Jump { location: 413 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 371 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 419 }, Jump { location: 425 }, Mov { destination: Relative(15), source: Relative(2) }, Jump { location: 421 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 428 }, Jump { location: 424 }, Jump { location: 425 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(15) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 432 }, Call { location: 524 }, Load { destination: Relative(18), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 437 }, Call { location: 527 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(19), rhs: Relative(12) }, JumpIf { condition: Relative(20), location: 440 }, Call { location: 521 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(19) }, Load { destination: Relative(20), source_pointer: Relative(22) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(9) }, JumpIf { condition: Relative(19), location: 447 }, Call { location: 521 }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 496 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(20) }, Store { destination_pointer: Relative(8), source: Relative(19) }, Mov { destination: Relative(16), source: Relative(2) }, Jump { location: 457 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, JumpIf { condition: Relative(17), location: 477 }, Jump { location: 460 }, Load { destination: Relative(16), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, JumpIf { condition: Relative(17), location: 464 }, Jump { location: 474 }, Load { destination: Relative(16), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Store { destination_pointer: Relative(6), source: Relative(18) }, Jump { location: 474 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Mov { destination: Relative(15), source: Relative(16) }, Jump { location: 421 }, Load { destination: Relative(17), source_pointer: Relative(7) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(16) }, Load { destination: Relative(19), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(17), rhs: Relative(18) }, JumpIf { condition: Relative(20), location: 486 }, Call { location: 524 }, Store { destination_pointer: Relative(7), source: Relative(18) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Mov { destination: Relative(16), source: Relative(17) }, Jump { location: 457 }, 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: 495 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, 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: 500 }, Jump { location: 502 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 517 }, 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: 514 }, 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: 507 }, 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: 517 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZnNbhs5EITfRWcf+NPNJvMqgREojrIQIMiGYi+wCPzuyxp2zSQHGQbn4v4kuWvIZk2TI/0+/Dh9f/vn2/n68/nX4cvX34fvt/Plcv7n2+X56fh6fr72d38fAv7EUA5f4kOP5rF6bCPG4DF6TB6zR/GoHl0vul50veh6yfWS6yXXS66XXC+5XnK93F8nxK6XEbue9CjBY9dTxOQxexSP6rHrFUTzWD22ETV4jB6Tx65niOJRPRaP5rF6bCOW4DF6TB5dr7hecb3ieqXrNcTqsY1oqFcAoECojKFCKI0ZATVHkaw51ECIBOigcBXpmGE1QiU0hxYIyMLwGparAoSghEIwQiW0ASlgGA3QBVMAZEIXTBGghEIwQhdMCdAcYNMB0MkAISBdAUaohOYAVw6IhETIBAgWgBIKofq1EgR7fVIOBAhiyjkRMkEISigEI1RCc4DhB1BZqCxUhukzignXDyiErpNRQxg7o2JwdsJawNoZs4C3ByBLAEaohOYAg2fUBw4fkAjQQX1g6gFIR1lg5wUsECIhETJBCEqADmYKhy8AY2fMovYswUxrzxLMtCqhD0MwZRhbMMEWCf2igunA2AOEoASkY14w9oA+DOnzyvCzGABZFYCsBigEI1QHmHbJQnPVAEiETED/igBzZbh3AZh2AHpbAtSxphmuW96B6zQDMkEISigEI3QdFUBzgOsGQFkBQoAOigCPDTACdDBBuG4BtNcB0MHg4cMBmSAEJRSCETjTxYeAxYcLREIiZIIQlGAOcJ1iUdhXMzw23sHWgLVAFx0QCYmQCULoOgU6cN0AI2DPwUVhvwHQQeVhvwFCgA4qD/sNMAJ0sAToqwAJgRAJiZAJQvCZynIGWMAIldAclnPAApGQCELAwPq6C5pnMUBZdmtBXyx93QR9cUAkJEImYIANoIRCMEIlNAc4dAB22gBIhEwQghIKwQjYwDEbeHYBeHZAJCRCJghBCdDpayvLzo8iLFu/AJRQCDbqVKrHNuLSHRGjx+Qxe1SPvBi8ugC8alhleHVAImQfELw6QAmFYAQo5/f3hwMPj99eb6cTzo5/nCb7GfPleDtdXw9frm+Xy8Ph3+PlbfmnXy/H6xJfj7f+aa/w6fqjxy7483w5gd4ftuxwP7W705Ml6pqun89H4xj5JUzkW+bgLctEfg3Mr6Huy495Jj+xfjXP1K9hu1/y21w+Dnyeb/fy6/38BF8v+X37n8jHZrWka5nI7sdjT48tzsxeuXpNZWd+m8m3Nd/KRH4MOCeNAgS9W/+oOxfwwyGsDoohhTmFtCrEqTJEHGyGQn82m1KodVVoabeCzSikuLq5Pw3NKOS1m3ScUki6jcHuziLJR4PAccoH8YerY/v8INqmEKYslXW1VB/OlILYXgXbxmB3uwMe8nbdmx8JfKK7fpS+t73274O2ErSyU6Efn2cUJK/3ZT+XziiUyD22o06Noeg6hjI1Bt16pE4dNPp3ZGsdVObqkNcxlDzVXYpuldTdCmWqDsXWOhSbq0NbFSzMHBuibc3FZKoOptsY5upgdW2yVqd2vJrWtah56u6u231Rberutrbu/HVuq/hLQWfapLX1EWImfXNTSFNdOqxFDG3nAKbyYy5bj54S2GxQ5kaw3Q0lTTxHfGIF674FrDvXr+5bvrpz9erOxas71+6DG1gDu5DGmWaswj6oMnX9wvrpVAtT416gtUzlr4e8alPjX+dvM/Mv61NLmXpoKcL6zR0JSuP1LczMv2i8c/3H/ur4dL799QvtO5Ru5+P3y8lf/ny7Pv3x6et/L/yEv/C+3J6fTj/ebicobT/z9j9fpY9eY33s3xf3Vy08xBAe8Uvv8ll8kFbwsn9d+FX7r0iaw+M7RvY/", + "debug_symbols": "pZnNbhs5EITfRWcf+NPdJPMqgREojrIQIMiGYi+wCPzuyxp2zSQHGQbn4v4kuWvIZk2TI/0+/Dh9f/vn2/n68/nX4cvX34fvt/Plcv7n2+X56fh6fr72d38fAv7EYIcv8aHH4rF6bCPG4DF6TB6zR/GoHl0vul50veh6yfWS6yXXS66XXC+5XnK93F8nxK6XEbue9CjBY9dTxOQxexSP6rHrGWLxWD22ETV4jB6Tx65XEMWjejSPxWP12Ea04DF6TB5dz1zPXM9cz7peQ6we24gF9QoAFAiVKagQSlMKATVHkUpzqIEQCdBB4SrSMcNaCJXQHFogIB3Da0ivgEwQghKMUAh1QAoQbIAumAIgEbpgigAhKMEIXTAlQCU0B/gzZUAmIF0BRiiESmgOsOeASEgECBpACEoofq0EwQJoDhmCmHKOhETIBCEowQiFUAnNQagsVBYqw/wZxYT7BygB9w9qCINnVAwOT1gLWDxjFvD4AGQJwAiFUAl9PBn1gdMHRAJ0UB+YewDSURbYekBzKIEQCYmQCUKADmYKqy8Ah2fMAsYWzLT2LMFMqxD6MARThsMFE4SxB/SLCqYDYw/IBCEgHfOCsQf0YUifV4afpQCQVQHIagAlGKEQmmehyWoAREIioI9FgLky3DugOcCQmgBlrGmG65Z34DrNgETIBCEowQhdRwVQCc0BrlMFZAJ0UISlxS5gBOhggnDdgOaAPqsYPHw4IBEyQQhKMAJnuvhwgeaw+HCBSEiETBCCOcB1ikWBx9BXMzw23sEWgbVAO10AZhsQCYmQCV3HoAPXDTAC9h5cFPYbAB1UHvYbkAnQQeVhvwFGgA6WAH11QBsgMOSASEiETPCZSlCCEQqhEprDciBYIBIyAQPr6y5onlYAuuzWgr5oFdAc4NABkZAIGGADCEEJRiiESmgOcGgJgEhIhEwQghKMgI0cs4FnBzQHeHZAJCRCJggBOn1tZTkBoAjLEUAAQlCCjTot/RGxemwjLs0RMXpMHsUjLwavDsCgscrw6oBISD4geHWAEJRgBCjn9/eHAw+P315vpxPOjn+cJvsZ8+V4O11fD1+ub5fLw+Hf4+Vt+adfL8frEl+Pt/5pr/Dp+qPHLvjzfDmB3h+27HA/tZvSkyXqmq6fz0fjGPkWJvJL5uBLlon8GphfQ92XH/NMfmL9ap6pX8N2v+S3uXwc+Dy/3Muv9/MTfL3k911/Ih+b1ZKuNpHdj8ee3g/BM7NXrl5T2ZnfZvLLml9sIj8GnJNGAYLerX/UnQv44RBWB8WQwpxCWhXiVBkiDjZDoT+bTSnUuiq0tFuhzCikuLq5PwTNKOS1m3ScUki6jaHcnUWSjwaB45QP4g9Xx/b5QbRNIUxZKutqqT6cKQUpexXKNoZytzvgIW/XvfmRwCe660fpe9tr/z5oK0GznQr91DyjIHm9L/txdEbBIvfYjjo1BtN1DDY1Bt16pE4dNPp3ZGsdVObqkNcxWJ7qLqZbJXW3gk3VwcpaBytzdWirQgkzx4ZYtuZSZKoORbcxzNWh1LXJljq149W0rkXNU3d33e6LWqbu7tLWnb/ObRV/KehMmyxtfYSYSd/cFNJUlw5rEUPbOYCp/Jht69FTApsNbG4E291gaeI54hMrWPctYN25fnXf8tWdq1d3Ll7duXYf3MAa2IU0zjRjFfZBlanrG+unUy1MC/cCrTaVvx7yapka/zr/MjN/W59abOqhxYT1mzsSWOP1S5iZv2m8c/3H/ur4dL799QvtO5Ru5+P3y8lf/ny7Pv3x6et/L/yEv/C+3J6fTj/ebicobT/z9j9fpe8+Gstj/5q4v2rhIYbwiF96l8/CgzTFy/4t4VftD3ea2uM7RvY/", "file_map": { "19": { "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 301e669f51a..e20a4332689 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -76,9 +76,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32837) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32842 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32847 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 104 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 162 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(6), location: 113 }, Jump { location: 118 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(6), location: 117 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 118 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(7), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Relative(6) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 168 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(7), location: 130 }, Jump { location: 146 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, 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: Direct(32836) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, 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) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 146 }, Load { destination: Relative(6), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 154 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(3) }, Mov { destination: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 178 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 167 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 162 }, Const { destination: Relative(2), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 173 }, Jump { location: 177 }, Const { destination: Relative(1), bit_size: Field, value: 1 }, Const { destination: Relative(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(3), op: Div, lhs: Relative(1), rhs: Relative(2) }, Jump { location: 177 }, Return, Call { location: 162 }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 185 }, Call { location: 207 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(7), size: 32 } }), Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(3) }, Mov { destination: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 210 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, JumpIf { condition: Relative(1), location: 206 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 162 }, 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(32835) }, 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: 220 }, Call { location: 207 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 226 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, JumpIf { condition: Relative(5), location: 231 }, Jump { location: 229 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(5), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 226 }]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32837) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32842 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32847 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 104 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 161 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(6), location: 157 }, Jump { location: 113 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(7), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Relative(6) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 167 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(7), location: 125 }, Jump { location: 141 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, 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: Direct(32836) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, 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) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 141 }, Load { destination: Relative(6), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 149 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(3) }, Mov { destination: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 177 }, Mov { destination: Direct(0), source: Relative(0) }, Return, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 161 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 166 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 161 }, Const { destination: Relative(2), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 172 }, Jump { location: 176 }, Const { destination: Relative(1), bit_size: Field, value: 1 }, Const { destination: Relative(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(3), op: Div, lhs: Relative(1), rhs: Relative(2) }, Jump { location: 176 }, Return, Call { location: 161 }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 184 }, Call { location: 206 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(7), size: 32 } }), Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(3) }, Mov { destination: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 209 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, JumpIf { condition: Relative(1), location: 205 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 161 }, 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(32835) }, 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: 219 }, Call { location: 206 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 225 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, JumpIf { condition: Relative(5), location: 230 }, Jump { location: 228 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(5), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 225 }]" ], - "debug_symbols": "pZbNbuJAEITfxWcO0z3/vEoURQZMZMkyyIGVVoh33+7QBezBEXIu1Gc8VR7a3caXZtdtzp8f/bg/fDXrt0uzmfph6D8/hsO2PfWHUb69NE4/yJVmTSvRelPyzZpVg2k0Taay3qvK+iDKzpRM2dSbBlPJiarppl58WZVM2dSbBtNomkyzaTGtNw2WFywvWF6wvCB5STWZSk5RLaaSU0WjMyVTNvWmkkNOIQISIAMKoBokB9BvtM7ZASSYtKI5ACIA9gJ7IQADPAAbK9hYwcaKbkyLXgqgGlQHIAADPCAANFmLVxMgAwqg3oCdAxCAAR4QAJbMhMWExYTF2pGUFSIgATKgAKqB9ucNCAAX6xq59+xxSpuQqoIHBIDOgVNIgAyQizIrIFCb8QaaXK7XVYPR+zhNXaeT9zSLMqHHdurGU7Mez8Owav60w/l70dexHb/11E5yVq7WjTtRCdz3Q6d0XT3cbt5KxGaW0b3b4+t+n+EPvMQfK/xp0fVjhD+7Jf6C4slcLPBLG5ufXZnzp3l/YvgTL6kfM+ov7fpL/6LfHzz8qSzw+xDM7+OS/fuE/vUpz/m1x2cDHArgyS/YQAho4DDfwBR+mqCEFpBhetwDGccXtxADahDjknsgT2ncBHlOh0fC60Pg6n0KfF0SQI8ATksCvHvsoPx2B3M/QYd1topM90che/ec8C4H7baf/nvRumrU1LebobPD/XncPp09/T3iDF7UjtNh2+3OU6dJj7c1+Vd6q25Fzr3rK5sckYwFpayH8lfzxtLk7Or7VffyDw==", + "debug_symbols": "pZbNjqpAEIXfhTWLrq7+qfZVJsag4oSEoGH0JjfGd79VQ5V4F0wMs/F8COd0ddMF3Ktju7997rrhdP6qNh/3aj92fd997vrzobl254H/vVdOfsBRtYGatUwKWG28aKg2KBpVk2pWJdUyqee4IAqq7EuiSTWrkmqZFJ0qqHpVVA2qmoeah5qHmoecF1kDqHJOFkVVziHRqJpUsyqpck5hjU4VVL0qqgbVqMo54ATIoCgkZyCnZJFTUcicCrJ8GQ2CAU3BWQsiLYi0INKCSAsiLYi0IOIJgqwEZQMyKArFGYCBN0ADKUhWuESDZJANyKBM4J0zAANvgAaa7MEuBrsY7GLZjpAFgkE0SAbZgAyKguzKCcwl+w/4Rnu0U7LzoAh4AzTgQb0TiAbJgAf1XuAZWBSCJNPjUVfWb7vr2LbSbi8NyG15acZ2uFab4db3dfWn6W/fF31dmuFbr83IZ3m0djiycuCp61uhRz273bIVwKuZ+/Rpj+/7YzF/WueP5s9ujZ9s8rydV/h596nfO1ryx2V/8uZP3q8Z32cbH+GX/lXzD2j+RGvWH218fp6u8GMI6se4Zv6YbP9iykt+2eOLAc4mgIArCgjBGiAsNwCEn1Yw2RbixZzvIbfjmyXEYGsQ46p7WMhuAj+ew5zwfhO58uwiLGsCYA7waU0AurkC+m0FS1OQZl9cRQ/PVuBXx2vClg+aQzf+93X1kKixa/Z9q4en23B4OXv9e7Ez9nV2Gc+H9ngbW0maP9H4ZfRRXA3ObeU7jY+A9xSkJIf87vrwLtX8fNs+pJZ/", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap index c1026a7172b..1036cc2bbd4 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap @@ -76,9 +76,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 208 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 112 }, Jump { location: 117 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 116 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Jump { location: 117 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 122 }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 132 }, Jump { location: 148 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 148 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 156 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 162 }, Call { location: 214 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 181 }, Call { location: 214 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 187 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 195 }, Jump { location: 190 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 194 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 187 }, 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: 213 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 207 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 203 }, Jump { location: 112 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 117 }, Jump { location: 121 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 121 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 127 }, Jump { location: 143 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 143 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 151 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 157 }, Call { location: 213 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 176 }, Call { location: 213 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 182 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 190 }, Jump { location: 185 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 189 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 182 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(1), location: 207 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, 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: 212 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tZbNbuowEIXfJess7Bn/8ipVhQKEKlIUUApXukK8+50BH8JdBKFU3XQ+Nz7HHntsfKl27eb8te6G/eG7Wn1cqs3Y9X33te4P2+bUHQb576Uy+seaUK1sLTHeo6VqRRq5RFeiL1H6scZUrbzGfI8kuqiRS3Qlin/SGO+RpZ81CgxwAA8IgAhIgFzAGYAFwNnB2cHZwdmJc9aYSlQ7TdsbgNppop4ADHAAD9CJOoUISIBcIBiABRCAAeocFDwgACIgAXKBaAAWoM66ypEBDqDOmnIMgAhIgFwgGYAFEACqLH1I1zRrH93qTAAGYNAsg5Iub46ABJBBSRaTjAFYgNaiU+D7WGQcQMvRXK91hZpen8a21ZJ+KnIp/WMztsOpWg3nvq+rP01/vnX6PjbDLZ6aUb6KZTvsJIrhvutbpWs9qc281Gol3MRyFh5y/76eI/SOluh9hj4sGt976KOZ07t5PTtX9OztEn3A+nGIc/rwQm+wfmx5Sf4Jm29TWKCXci16MmlOn+f1gaAPtGT/iZA/sf2hflH+jqEPs/lb/kUDb3ACPM2eAOtfHcGAPZDTOC2CnOe35+BQxd7PJxF/0UBuVBxEuVPdZPG2g9zA+VHKnBc52MmBwiIHNtMc0o/nMJcFvdhLS/ZxJRObZ4dPaTTbbvzvJXVVq7FrNn1bmvvzsH36evp7xBe8xI7jYdvuzmOrTtNzTH7nPrKprTGf+iaTllwqNVnWptWmvBfIhs+rzuUf", + "debug_symbols": "tZbNbuowEIXfJWsW9vgndl6lQihAqCJFAaVwpSvEu3emzCHtwgil6qbnc5Nz7HFs42u177aX900/Ho4fVfN2rbZTPwz9+2Y47tpzfxz5v9fKyB9rYtXYFWt9V0tVQ6KuaryoV+XnUTSp5ruSrZpalFT5vSyaVPNdnVG1qqTqVL1qUI2qmuc0z2me1zzPeUnUqXKONQIBIBVKab4GJEBWCAbAcdYJEMABPCAAIqAGJIAkB4ZoABZAAAfwgACIAEmWeY0JkBVqSZaSawsggAN4QABEQK2Q4Eryjsxpknfk46YakBQyOs3cKcn0ZgI4AHdKMpk5ACKAA0nmJyftK+c7kDEAyfECHhAAkuNvt1WFlbw5T10nC/nb0uYFf2qnbjxXzXgZhlX1rx0uXy99nNrxS8/txE95sN24Z+XAQz90QrfV7DZlK+8TNfNOeNjD6/6Q4Y/L/AH+2pT8rux33qvfBbvEH1G/i3XJH574TQ2/dUvqT/h4vFoX+MlY9ZNJJX8q+yPBH4mW9E+on5z9pX9R/d7BH4v1yxr/s4BgsAMCFXeA9U+WgIv4BvwrMU8C78eXx+CxikMoFxH/MIAPQmxEPgr9HPFyAh+c+bGUXV6UYOcEiosSnJnHkH49hlIV9ORb8k0EW8KSM4WEZ0eKe/j9zy295la766cf96ebJE19ux06bR4u4+7b0/P/E57g/nWajrtuf5k6SZovYfyD95bNyhqzlpsYt4iPR7IkTStNvlOQDeubjOUT", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index c1026a7172b..1036cc2bbd4 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -76,9 +76,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 208 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 112 }, Jump { location: 117 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 116 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Jump { location: 117 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 122 }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 132 }, Jump { location: 148 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 148 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 156 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 162 }, Call { location: 214 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 181 }, Call { location: 214 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 187 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 195 }, Jump { location: 190 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 194 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 187 }, 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: 213 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 207 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 203 }, Jump { location: 112 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 117 }, Jump { location: 121 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 121 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 127 }, Jump { location: 143 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 143 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 151 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 157 }, Call { location: 213 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 176 }, Call { location: 213 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 182 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 190 }, Jump { location: 185 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 189 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 182 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(1), location: 207 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, 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: 212 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tZbNbuowEIXfJess7Bn/8ipVhQKEKlIUUApXukK8+50BH8JdBKFU3XQ+Nz7HHntsfKl27eb8te6G/eG7Wn1cqs3Y9X33te4P2+bUHQb576Uy+seaUK1sLTHeo6VqRRq5RFeiL1H6scZUrbzGfI8kuqiRS3Qlin/SGO+RpZ81CgxwAA8IgAhIgFzAGYAFwNnB2cHZwdmJc9aYSlQ7TdsbgNppop4ADHAAD9CJOoUISIBcIBiABRCAAeocFDwgACIgAXKBaAAWoM66ypEBDqDOmnIMgAhIgFwgGYAFEACqLH1I1zRrH93qTAAGYNAsg5Iub46ABJBBSRaTjAFYgNaiU+D7WGQcQMvRXK91hZpen8a21ZJ+KnIp/WMztsOpWg3nvq+rP01/vnX6PjbDLZ6aUb6KZTvsJIrhvutbpWs9qc281Gol3MRyFh5y/76eI/SOluh9hj4sGt976KOZ07t5PTtX9OztEn3A+nGIc/rwQm+wfmx5Sf4Jm29TWKCXci16MmlOn+f1gaAPtGT/iZA/sf2hflH+jqEPs/lb/kUDb3ACPM2eAOtfHcGAPZDTOC2CnOe35+BQxd7PJxF/0UBuVBxEuVPdZPG2g9zA+VHKnBc52MmBwiIHNtMc0o/nMJcFvdhLS/ZxJRObZ4dPaTTbbvzvJXVVq7FrNn1bmvvzsH36evp7xBe8xI7jYdvuzmOrTtNzTH7nPrKprTGf+iaTllwqNVnWptWmvBfIhs+rzuUf", + "debug_symbols": "tZbNbuowEIXfJWsW9vgndl6lQihAqCJFAaVwpSvEu3emzCHtwgil6qbnc5Nz7HFs42u177aX900/Ho4fVfN2rbZTPwz9+2Y47tpzfxz5v9fKyB9rYtXYFWt9V0tVQ6KuaryoV+XnUTSp5ruSrZpalFT5vSyaVPNdnVG1qqTqVL1qUI2qmuc0z2me1zzPeUnUqXKONQIBIBVKab4GJEBWCAbAcdYJEMABPCAAIqAGJIAkB4ZoABZAAAfwgACIAEmWeY0JkBVqSZaSawsggAN4QABEQK2Q4Eryjsxpknfk46YakBQyOs3cKcn0ZgI4AHdKMpk5ACKAA0nmJyftK+c7kDEAyfECHhAAkuNvt1WFlbw5T10nC/nb0uYFf2qnbjxXzXgZhlX1rx0uXy99nNrxS8/txE95sN24Z+XAQz90QrfV7DZlK+8TNfNOeNjD6/6Q4Y/L/AH+2pT8rux33qvfBbvEH1G/i3XJH574TQ2/dUvqT/h4vFoX+MlY9ZNJJX8q+yPBH4mW9E+on5z9pX9R/d7BH4v1yxr/s4BgsAMCFXeA9U+WgIv4BvwrMU8C78eXx+CxikMoFxH/MIAPQmxEPgr9HPFyAh+c+bGUXV6UYOcEiosSnJnHkH49hlIV9ORb8k0EW8KSM4WEZ0eKe/j9zy295la766cf96ebJE19ux06bR4u4+7b0/P/E57g/nWajrtuf5k6SZovYfyD95bNyhqzlpsYt4iPR7IkTStNvlOQDeubjOUT", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 0dfda76646a..a8828780391 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -50,9 +50,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32857 }, 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(32856), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32856) }, Call { location: 13 }, Call { location: 35 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32857 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U1), 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(U8), value: 34 }, Const { destination: Direct(32840), bit_size: Integer(U8), value: 44 }, Const { destination: Direct(32841), bit_size: Integer(U8), value: 50 }, Const { destination: Direct(32842), bit_size: Integer(U8), value: 51 }, Const { destination: Direct(32843), bit_size: Integer(U8), value: 58 }, Const { destination: Direct(32844), bit_size: Integer(U8), value: 100 }, Const { destination: Direct(32845), bit_size: Integer(U8), value: 101 }, Const { destination: Direct(32846), bit_size: Integer(U8), value: 103 }, Const { destination: Direct(32847), bit_size: Integer(U8), value: 104 }, Const { destination: Direct(32848), bit_size: Integer(U8), value: 105 }, Const { destination: Direct(32849), bit_size: Integer(U8), value: 107 }, Const { destination: Direct(32850), bit_size: Integer(U8), value: 110 }, Const { destination: Direct(32851), bit_size: Integer(U8), value: 114 }, Const { destination: Direct(32852), bit_size: Integer(U8), value: 115 }, Const { destination: Direct(32853), bit_size: Integer(U8), value: 116 }, Const { destination: Direct(32854), bit_size: Integer(U8), value: 123 }, Const { destination: Direct(32855), bit_size: Integer(U8), value: 125 }, Return, Call { location: 175 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 181 }, Mov { destination: Direct(0), source: Relative(0) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 46 }, Call { location: 392 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 395 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 38 }, 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(32854) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32849) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, 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: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32852) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32840) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32847) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32842) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 395 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 149 }, Call { location: 442 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 157 }, Call { location: 445 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 395 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 170 }, Call { location: 442 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 180 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, JumpIf { condition: Relative(3), location: 224 }, Jump { location: 187 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 220 }, Jump { location: 190 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Direct(32835), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 218 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(9), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, Mov { destination: Relative(10), source: Relative(9) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(11) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(12) }, Call { location: 448 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(9), size: Relative(8) } }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 222 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 222 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 226 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 226 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 108 }, JumpIf { condition: Relative(1), location: 317 }, Jump { location: 230 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 239 }, Jump { location: 233 }, Const { destination: Relative(1), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 238 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 391 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Relative(6), source: Relative(5) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Direct(32845) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32842) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(2), size: 3 }), HeapArray(HeapArray { pointer: Relative(3), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 391 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(4), source: Direct(32847) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Direct(32848) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(4) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32841) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(3), size: 2 }), HeapArray(HeapArray { pointer: Relative(4), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 391 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 411 }, Jump { location: 402 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 413 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 413 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 438 }, Jump { location: 416 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 430 }, Jump { location: 419 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 423 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 428 }, Call { location: 445 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 436 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 434 }, Call { location: 445 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 436 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 440 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 440 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 458 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 451 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32857 }, 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(32856), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32856) }, Call { location: 13 }, Call { location: 35 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32857 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U1), 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(U8), value: 34 }, Const { destination: Direct(32840), bit_size: Integer(U8), value: 44 }, Const { destination: Direct(32841), bit_size: Integer(U8), value: 50 }, Const { destination: Direct(32842), bit_size: Integer(U8), value: 51 }, Const { destination: Direct(32843), bit_size: Integer(U8), value: 58 }, Const { destination: Direct(32844), bit_size: Integer(U8), value: 100 }, Const { destination: Direct(32845), bit_size: Integer(U8), value: 101 }, Const { destination: Direct(32846), bit_size: Integer(U8), value: 103 }, Const { destination: Direct(32847), bit_size: Integer(U8), value: 104 }, Const { destination: Direct(32848), bit_size: Integer(U8), value: 105 }, Const { destination: Direct(32849), bit_size: Integer(U8), value: 107 }, Const { destination: Direct(32850), bit_size: Integer(U8), value: 110 }, Const { destination: Direct(32851), bit_size: Integer(U8), value: 114 }, Const { destination: Direct(32852), bit_size: Integer(U8), value: 115 }, Const { destination: Direct(32853), bit_size: Integer(U8), value: 116 }, Const { destination: Direct(32854), bit_size: Integer(U8), value: 123 }, Const { destination: Direct(32855), bit_size: Integer(U8), value: 125 }, Return, Call { location: 175 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 181 }, Mov { destination: Direct(0), source: Relative(0) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 46 }, Call { location: 390 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 393 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 38 }, 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(32854) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32849) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, 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: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32852) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32840) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32847) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32842) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 393 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 149 }, Call { location: 440 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 157 }, Call { location: 443 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 393 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 170 }, Call { location: 440 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 180 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, JumpIf { condition: Relative(3), location: 222 }, Jump { location: 187 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(3), location: 218 }, Jump { location: 190 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Direct(32835), rhs: Direct(32837) }, JumpIf { condition: Relative(3), location: 218 }, 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: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, Mov { destination: Relative(6), source: Relative(5) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(6) }, Mov { destination: Direct(32773), source: Relative(8) }, Call { location: 446 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(5), size: Relative(4) } }, Mov { destination: Relative(1), source: Relative(5) }, Jump { location: 220 }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 224 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 224 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 108 }, JumpIf { condition: Relative(1), location: 315 }, Jump { location: 228 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 237 }, Jump { location: 231 }, Const { destination: Relative(1), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 236 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 389 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Relative(6), source: Relative(5) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Direct(32845) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32842) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(2), size: 3 }), HeapArray(HeapArray { pointer: Relative(3), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 389 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(4), source: Direct(32847) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Direct(32848) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(4) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32841) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(3), size: 2 }), HeapArray(HeapArray { pointer: Relative(4), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 389 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 409 }, Jump { location: 400 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 411 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 411 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 436 }, Jump { location: 414 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 428 }, Jump { location: 417 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 421 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 426 }, Call { location: 443 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 434 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 432 }, Call { location: 443 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 434 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 438 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 438 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 456 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 449 }, Return]" ], - "debug_symbols": "tdjNThtLEEDhd/GaxfRvVfMqURQ5YCJLlkEOXOkK8e63y1XHFxZGyBab1CGkP9vjnvHEr6v7ze+XP7+2+4fHv6vbH6+r34ftbrf982v3eLd+3j7u59++rhb7o/TVbbpZFfGhPsZx1MVH8pFXt3mO4qP6aD6mUuYQH+pjHEdbfCQf2cdU+hzVR/PRfYgP9TGOoy8+ko/sw5XuSnelu9Jd6a50V8QVcUVcEVfEFXFFXBFXxBVxRV1RV9QVdUVdUVfUFXVFXVFXhivDleHKcGW4MlwZrgxXhivDlbQsMVPMHLPErDFbzB5TYmrM8FJ4KbwUXgovhZfCS+Gl8FJ4KbwcXg4vh5fDy+Hl8HJ4ObwcXg6vhFfCK+GV8Mr0xGaLOT21KTE15vBpm/w4U8wcc3opWVSiEZ0QQokRYbvew86ebJEJk4tFJRrRCZOrhRIjws4Ej0RkohAm26u3c8KjE0IoMSLs7PBIhMl2NOwcOYbt9jQsppOXGbaPPRKRiUJUohGdODnz+WQ7PrazLbJtbY9EZKIQlWhEJ4RQAjkhJ+SEnJATckJOyAnZNmue71e2XelRiEo04vSPhbDnM9+vbJvQIxGZKEQlGtEJIZRAbsgN2fZhFotCVKIRnRBCiRFh+9AjEcgduSN35I7ckTtyRxZkQRZkQRZkQRZkQRZkQVZkRVZkRVZkRVZkRVZkRR7IA3kgD+SBPJAH8kAeyCPksixEIjJRiEo0ohNCKIGckBNyQj6eBWpRiUYYOCyUGBF2rfdIRCYKUYlG2M1DthBCiRFh55dHIjJRiEo0ArkgF+SCXJErckWuyBW5IlfkilyRK3JDbsgNuSE35IbckBtyQ27IHbkjd+SO3JE7ckfuyB25IwuyIAuyIAuyIAuyIAuyICuyIiuyIiuyIiuynXqlWCgxIuwkKtVuVw1sFiXCtnHpFp0YEbZXPRKRCVslFpVoRCck4rgz1SIRmTBH395uVtx3/3o+bDZ22/3uRnzenj+tD5v98+p2/7Lb3az+We9ejv/o79N6f5zP68P87fyQ3Ozv55zgw3a3sXq7+X/1cn6pfVgd19Z8Wty+vHqUWD30gtWts3pcsLpqrJ43uueW1/PLdSQePZfT+pw/rG/ft16qxHrR5dz6T15+sts5f/2tXHD45u3+aX09t35c+frT8o3AtUdw3hjG+nnXd8kR7Hpany5av5zWnz350rVbMPVvBK59C+ZHfayfH98XHML5wcf63i65hiy8BfX8W5jTJweAy6fIaXktX374XE5X33724ctVD//Z8nnfyeFbzl7A87U7MPdvBL60Az89hNcC8/80nMZy9k0s114IS/pG4NrTuC+chj1dchr2yiHs9ZJbgT64Esty9kpaPtlFTXkCbVwGVD5NW/t4BH7On9Z328OHb1jfTDps1793m/jx4WV/9+63z/8+8Ru+oX06PN5t7l8OG5PefU077xPrvBeqTX/al3XzxyTtJuliP847zx9l5Jsy6s83ezL/AQ==", + "debug_symbols": "tdjNThtLEEDhd/GaxfRfVTevEkWRAyayZBnkwJWuEO9+u1x1fGFhhGyxSR1C+rM97hlP/Lq63/x++fNru394/Lu6/fG6+n3Y7nbbP792j3fr5+3jfv7t62qxP4qsbtPNqqiP7mMcR118JB95dZvnKD6qj+ZjKmUO9dF9jONoi4/kI/uYisxRfTQf4kN9dB/jOGTxkXxkH66IK+KKuCKuiCviirqirqgr6oq6oq6oK+qKuqKudFe6K92V7kp3pbvSXemudFe6K8OV4cpwZbgyXBmuDFeGK8OV4UpalpgpZo5ZYtaYLabE1Jg9ZngpvBReCi+Fl8JL4aXwUngpvBReDi+Hl8PL4eXwcng5vBxeDi+HV8Ir4ZXwSnhlemqzxZxet6kxe8zh0zb5caaYOeb0UrKoRCOEUKITI8J2vYedPdkiEyYXi0o0QgiTq0UnRoSdCR6JyEQhTLZXb+eEhxBKdGJE2NnhkQiT7WjYOXIM2+1pWEwnLzNsH3skIhOFqEQjhDg58/lkOz62sy2ybW2PRGSiEJVohBBKdAI5ISfkhJyQE3JCTsgJ2TZvLhY9wralRyYKwT+2relhTrXoxIiwbemRiEwUohKNEAK5Ildk25lZLRKRiUJUohFCKNGJESHIgizIgizIgizIgizIgqzIiqzIiqzIiqzIiqzIityRO3JH7sgduSN35I7ckTvyQB7IA3kgD+SBPJAH8kAeIZdlIRKRiUJUohFCKNEJ5IR8PC+6RSYKYeCwEEKJTowIu/p7JCIThZhPtWSLRgihRCdGhH0OeCQiE4VALsgFuSAX5IJckStyRa7IFbkiV+SKXJErckNuyA25ITfkhtyQG3JDbsiCLMiCLMiCLMiCLMiCLMiKrMiKrMiKrMiKrMiKrMgduSN35I7cke3UK8VCCI2wk6hUu101sFmkCNvGRSwqoUQnRoTtVQ9bpRaZKEQlGmFOtxgRx515DHP629vNivvuX8+HzcZuu9/diM/b86f1YbN/Xt3uX3a7m9U/693L8R/9fVrvj/N5fZi/nR+Sm/39nBN82O42Vm83/69ezi+1D6vj2ppPi9uXV48Sq0e/YHUTVo8LVtceq+eN7rnl9fzyPhKPnstpfc4f1rfvW69VY7325dz6T15+sts5f/2tXHD45u3+aX09t35c+frT8o3AtUdw3hjG+nnXd8kRlH5any5av5zWnz350rVbMMk3Ate+BfODPdbPD+sLDuH8mGO9tEuuIQtvQT3/Fub0yQHg8ql6Wl7Llx8+l9PVV84+fLnq4T9bPu8yOXzL2Qt4vnYHZvlG4Es78NNDeC0w/wfDaaxn38Ry7YWwpG8Erj2NZeE0lHTJaSiVQyj1klsBGVyJdTl7JS2f7KLWeQJtXAZUPk1b+3gEfs6f1nfbw4dvWN9MOmzXv3eb+PHhZX/37rfP/z7xG76hfTo83m3uXw4bk959TTvvE+t89Nrkp31ZN39M2m5SX+zHeZ/5o4zlpoz8882ezH8=", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap index 019e62ec4fd..a121db9ff0e 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap @@ -50,9 +50,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32837) }, Call { location: 13 }, Call { location: 16 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 378 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, Const { destination: Relative(6), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(3), location: 61 }, Jump { location: 24 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 57 }, Jump { location: 27 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(9), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(9), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Mov { destination: Relative(11), source: Relative(10) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(7) }, JumpIf { condition: Relative(10), location: 55 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, Mov { destination: Relative(13), source: Relative(12) }, IndirectConst { destination_pointer: Relative(13), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(14) }, Mov { destination: Direct(32772), source: Relative(13) }, Mov { destination: Direct(32773), source: Relative(15) }, Call { location: 384 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(8) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(12), size: Relative(11) } }, Mov { destination: Relative(3), source: Relative(8) }, Jump { location: 59 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 59 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 63 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 63 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(3), location: 171 }, Jump { location: 84 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 93 }, Jump { location: 87 }, Const { destination: Relative(3), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 92 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Jump { location: 245 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(25) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(25) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(25), source: Relative(3) }, Store { destination_pointer: Relative(25), source: Relative(9) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(11) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(13) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(15) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(19) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(20) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(21) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(4) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(24) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(23) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(3), size: 3 }), HeapArray(HeapArray { pointer: Relative(20), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(4) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(25), source: Relative(5) }, Store { destination_pointer: Relative(25), source: Relative(9) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(11) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(13) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(15) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(19) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(20) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(21) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(4) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(23) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(5), size: 2 }), HeapArray(HeapArray { pointer: Relative(20), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32836), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 249 }, Call { location: 395 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 25 }, Mov { destination: Relative(25), source: Direct(0) }, Mov { destination: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(26) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(25) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(25) }, Store { destination_pointer: Relative(26), source: Relative(9) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(15) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(17) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(19) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(5) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(4) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(23) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 21 }, Mov { destination: Relative(21), source: Direct(0) }, Mov { destination: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(22) }, Load { destination: Relative(3), source_pointer: Relative(20) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 352 }, Call { location: 445 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 360 }, Call { location: 448 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 21 }, Mov { destination: Relative(21), source: Direct(0) }, Mov { destination: Relative(22), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(22) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 373 }, Call { location: 445 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 383 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 394 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 387 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 378 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 414 }, Jump { location: 405 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 416 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 416 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 441 }, Jump { location: 419 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 433 }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 426 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 431 }, Call { location: 448 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 439 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 437 }, Call { location: 448 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 439 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 443 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 443 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32837) }, Call { location: 13 }, Call { location: 16 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 376 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, Const { destination: Relative(6), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(3), location: 59 }, Jump { location: 24 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(3), location: 55 }, Jump { location: 27 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(7) }, JumpIf { condition: Relative(3), location: 55 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, Mov { destination: Relative(8), source: Relative(5) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(9) }, Mov { destination: Direct(32772), source: Relative(8) }, Mov { destination: Direct(32773), source: Relative(10) }, Call { location: 382 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(5), size: Relative(4) } }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 57 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 61 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 61 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(3), location: 169 }, Jump { location: 82 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 91 }, Jump { location: 85 }, Const { destination: Relative(3), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 90 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Jump { location: 243 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(25) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(25) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(25), source: Relative(3) }, Store { destination_pointer: Relative(25), source: Relative(9) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(11) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(13) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(15) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(19) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(20) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(21) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(4) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(24) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(23) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(3), size: 3 }), HeapArray(HeapArray { pointer: Relative(20), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 243 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(4) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(25), source: Relative(5) }, Store { destination_pointer: Relative(25), source: Relative(9) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(11) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(13) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(15) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(19) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(20) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(21) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(4) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(23) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(5), size: 2 }), HeapArray(HeapArray { pointer: Relative(20), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 243 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32836), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 247 }, Call { location: 393 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 25 }, Mov { destination: Relative(25), source: Direct(0) }, Mov { destination: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 396 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(26) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(25) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(25) }, Store { destination_pointer: Relative(26), source: Relative(9) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(15) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(17) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(19) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(5) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(4) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(23) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 21 }, Mov { destination: Relative(21), source: Direct(0) }, Mov { destination: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 396 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(22) }, Load { destination: Relative(3), source_pointer: Relative(20) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 350 }, Call { location: 443 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 358 }, Call { location: 446 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 21 }, Mov { destination: Relative(21), source: Direct(0) }, Mov { destination: Relative(22), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 396 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(22) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 371 }, Call { location: 443 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 381 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 392 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 385 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 376 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 412 }, Jump { location: 403 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 414 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 414 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 439 }, Jump { location: 417 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 431 }, Jump { location: 420 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 424 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 429 }, Call { location: 446 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 437 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 435 }, Call { location: 446 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 437 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 441 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 441 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tdjNThtZEEDhd+m1F11V95dXiRAyYCJLlkEOjDRCvHtu9b2HhEWjyJY3U8fj1GdounHj9+lxd//2825/fHr+Nd38eJ/uT/vDYf/z7vD8sH3dPx/b/32fZv+P5OlGN5OG6cbayH2UPuoybO5D+tA+rI++Z3G6iW2kPnIfpY+6jDD3IX1oH9ZH6KMroSuhK6EroSuxK7ErsSuxK7ErqT1Km6mEPnIfpY+6jDr3IX20hdxG6CP2kfrIfZQ+6jJknseUMXVMGzOMGcdsmMwemShEHSEzIYQSRgQiEsiCLMiCrMiKrMiKrMiKrMiKrMiKbMiGbMiGbMiGbMiGbMiGHJADckAOyAE5IAfkgByQA3JEjsgROSJH5IgckSNyRI7ICTkhJ+SEnJATckJOLotHIeqI7KB6KGFEICKRiEwUoo4o/qVGDyGUMCIQkUhEJgpRR1TkilyRK3JFrsgVuSJX5DpknWdCCCWMCEQkEpGJQiALsiALsiALsiALsiALsiArsiIrsiIrsiIrsiIrsiIbsiEbsiEbsiEbsiEbsiEH5OXSSx5KGOFg9khEJgrhYGmxXHFLCKGEEYGIRJNVPDJRiDrCr7geQihhRCAigZyQE3JCzsgZOSNn5IyckTNyRs7IGbkgF+SCXJALckEuyAW5IBfkilyRK3JFrsgVuSJX5Ipch2zzTAihhBGBiEQiMlEIZEEWZEEWZEEWZEEWZEEWZEVWZEVWZEVWZEVWZEVWZEM2ZEM2ZEM2ZEP2S0/VoxAuLzdTMyGEEkYEIhIuJ49MFKKO8GuwhxBKGOFy9oiEy8UjE4WoI5ZrsHoIoYQRgYhEIvyO0w+CX4M96gi/BnsIoYQRgWiy+dHwa3AJP3st+I2nP7XcgaYRfv5Y8qgj/NzoYUQgIuFb2SMThagjlnvlJdwpHoGIhDvl42MzcTt+93ra7fxu/K/783bX/rI97Y6v083x7XDYTP9tD2/LP/r1sj0u83V7as+2e4fd8bHNBj7tDzuvj82f7Xl91c++ZTfo53L8ui3r2+2qGevtSjhnP1b2UzxjP8x860FWXz+s72e++5w/t4P986v7tTcOXlp79XTRq3+z3X6Rc+zmsvbqZX2/VBn7Ve1zX/XLfr3efg6Zb7/Ma/vpevvt/mDstzft1XPPLjwAEq4I/NMh+ObirxyBunoCfbMdE9v1jO1Qxnb7U3r16F96+ul8ReDSoy/CBdz+7DzjCLbPFD73w9q+Xnr++W/4qwGXHsL2Rx7XsMznHMJUPvflrP35c3/1/dMuPQlNrghc+iNIM2/hSeIZhzAFfgmlcM7vkVT5EeZ5/UfwzftALHwBsZ4HBK7DGL8egdv2aPuwP3350PXDpdN+e3/YjYdPb8eHv559/f+FZ/jQ9uX0/LB7fDvtXPrzyW27wfxhJWyshlv/INEf5rKxYv5Q/GGN7dl8++FfzG8=", + "debug_symbols": "tdjNThtZEEDhd+m1F11V95dXiRAyYCJLlkEOjDRCvHtu9b2HhEWjyJY3U4dx6jM03Xbj9+lxd//2825/fHr+Nd38eJ/uT/vDYf/z7vD8sH3dPx/b/32fZv+P5OlGN5OG6cbayH2UPuoybO5D+tA+rI++Z3G6iW2kPnIfpY+6jDD3IX1oH9ZH6KMroSuhK6EroSuxK7ErsSuxK7ErqT2WNlPRPmIfqY/cR+mjLqO2hdyG9mF9hD5iH6mP3Efpoy5D5nlMGVPHtDEbJbNHJBKRiULUETITQihhBLIgC7IgC7IgK7IiK7IiK7IiK7IiK7IiG7IhG7IhG7IhG7IhG7IhB+SAHJADckAOyAE5IAfkgByRI3JEjsgROSJH5IgckSNyQk7ICTkhJ+TksngkIhMOtmtU8kwIoYQRgYhEIjLh32r0qCPKTAihhBGBiEQiMoFckCtyRa7IFbkiV+SKXJErch2yzjMhhBJGBCISichEIZAFWZAFWZAFWZAFWZAFWZAVWZEVWZEVWZEVWZEVWZEN2ZAN2ZAN2ZAN2ZANebn0kr8zzIQQDmaPQEQiEQ4Wj0LUEcsVt4QQShjRZBWPSCQiE4WoI/yK6yGEEkYgJ+SEnJATckLOyBk5I2fkjJyRM3JGzsgZuSAX5IJckAtyQS7IBbkgF+SKXJErckWuyBW5IlfkilyHbPNMCKGEEYGIRCIyUQhkQRZkQRZkQRZkQRZkQRZkRVZkRVZkRVZkRVZkRVZkQzZkQzZkQ/ZLT9UjES4vd1SFqCP80ushhBJGuJw8IpGITBSijvBrsIcQLmcPI1wuHpFIRCZcrh51xHINLiGEEkYEosnmB8GvwR6ZKEQd4ddgDyGU8LtRPxp+DS7hZ68Fv+30h5b7zzDCzx9LHnmEnxs9hFDCCN/KHpFIRCbKiOVeuXgoYYQ75eNjM3Ezfvd62u38Xvyvu/N2z/6yPe2Or9PN8e1w2Ez/bQ9vyz/69bI9LvN1e2qPtnuH3fGxzQY+7Q87r4/Nn+15fdXPvmU36Ody/Lot69vtGhnr7bw/Zz9W9lM8Yz/M/OhBVp8/rO9nfvqcP7eD/fOz+7U3Dl5ae/Z00bN/s91etjl2c1l79rK+X6qM/ar2ua/6Zb9ebz+HzI9f5rX9dL39djcw9ttb9Oq5ZxceAAlXBP7pEHxz8VeOQF09gb7ZjontesZ2KGO7/em8evQvPf10viJw6dEX4QJuf2SecQTbJwif+2FtXy89//wV/mrApYew/UnHNSzzOYcwlc99OWt//txfff+0S09CkysCl/4K0sxbeJJ4xiFMgRehFM55HUmVX2Ge138F37wPxMI3EOt5QOA6jPHrEbhtX20f9qcvH7l+uHTab+8Pu/Hl09vx4a9HX/9/4RE+sn05PT/sHt9OO5f+fG7bbid/WNGNVb31jw39y5w2VsS/FP+yvcRbjbcf/s38Bg==", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 8985f326da4..1db2c1067b9 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -50,9 +50,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 479 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, Const { destination: Relative(7), bit_size: Field, value: 8 }, Const { destination: Relative(8), bit_size: Field, value: 9 }, Const { destination: Relative(9), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 61 }, Jump { location: 25 }, JumpIf { condition: Relative(6), location: 57 }, Jump { location: 27 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(13), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(13), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 55 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(16), source: Direct(1) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(17) }, Mov { destination: Relative(17), source: Relative(16) }, IndirectConst { destination_pointer: Relative(17), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(18) }, Mov { destination: Direct(32772), source: Relative(17) }, Mov { destination: Direct(32773), source: Relative(19) }, Call { location: 485 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(12) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(16), size: Relative(15) } }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 59 }, Mov { destination: Relative(11), source: Relative(8) }, Jump { location: 59 }, Mov { destination: Relative(2), source: Relative(11) }, Jump { location: 63 }, Mov { destination: Relative(2), source: Relative(7) }, Jump { location: 63 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(26), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(28), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(11), location: 171 }, Jump { location: 84 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 93 }, Jump { location: 87 }, Const { destination: Relative(8), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 92 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 245 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(29) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(30), source: Relative(29) }, Store { destination_pointer: Relative(30), source: Relative(2) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(8) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(25) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(29), source: Relative(8) }, Store { destination_pointer: Relative(29), source: Relative(13) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(15) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(17) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(19) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(21) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(23) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(25) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(7) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(27) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(8), size: 3 }), HeapArray(HeapArray { pointer: Relative(24), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Relative(29), source: Relative(11) }, Store { destination_pointer: Relative(29), source: Relative(13) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(15) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(17) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(19) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(21) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(23) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(25) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(7) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(26) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(27) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(11), size: 2 }), HeapArray(HeapArray { pointer: Relative(24), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 245 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 249 }, Call { location: 496 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Const { destination: Relative(24), bit_size: Field, value: 4 }, Const { destination: Relative(29), bit_size: Field, value: 5 }, Const { destination: Relative(30), bit_size: Field, value: 6 }, JumpIf { condition: Relative(11), location: 264 }, Jump { location: 255 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(31), source: Relative(11), bit_size: U1 }, Cast { destination: Relative(32), source: Relative(11), bit_size: Field }, Cast { destination: Relative(11), source: Relative(31), bit_size: Field }, BinaryFieldOp { destination: Relative(31), op: Mul, lhs: Relative(32), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(32), op: Mul, lhs: Relative(11), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(31), rhs: Relative(32) }, Mov { destination: Relative(2), source: Relative(11) }, Jump { location: 266 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 266 }, BinaryFieldOp { destination: Relative(31), op: Equals, lhs: Relative(2), rhs: Relative(24) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(31), location: 291 }, Jump { location: 270 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(33), location: 283 }, Jump { location: 273 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(33), location: 277 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(32) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 281 }, Call { location: 499 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 289 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 287 }, Call { location: 499 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 289 }, Mov { destination: Relative(11), source: Relative(31) }, Jump { location: 293 }, Mov { destination: Relative(11), source: Relative(8) }, Jump { location: 293 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(31), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(33), source: Direct(1) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(34) }, IndirectConst { destination_pointer: Relative(33), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, Mov { destination: Relative(35), source: Relative(34) }, Store { destination_pointer: Relative(35), source: Relative(13) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(15) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(8) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(19) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(22) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(20) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(22) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(21) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(23) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(31) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(20) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(7) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(28) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(26) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(27) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(11)), HeapArray(HeapArray { pointer: Relative(7), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, JumpIf { condition: Relative(4), location: 386 }, Jump { location: 378 }, Not { destination: Relative(4), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(7), source: Relative(6), bit_size: Field }, Cast { destination: Relative(6), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Mul, lhs: Relative(7), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(6), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(6), op: Add, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(6) }, Jump { location: 388 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 388 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(24) }, JumpIf { condition: Relative(6), location: 412 }, Jump { location: 391 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(7), location: 404 }, Jump { location: 394 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(7), location: 398 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(32) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 402 }, Call { location: 499 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 410 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 408 }, Call { location: 499 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 410 }, Mov { destination: Relative(4), source: Relative(6) }, Jump { location: 414 }, Mov { destination: Relative(4), source: Relative(1) }, Jump { location: 414 }, Load { destination: Relative(6), source_pointer: Relative(33) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 420 }, Call { location: 502 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(4)), HeapArray(HeapArray { pointer: Relative(6), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 428 }, Call { location: 499 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(1), location: 440 }, Jump { location: 431 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Not { destination: Relative(3), source: Relative(1), bit_size: U1 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Cast { destination: Relative(1), source: Relative(3), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(6), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(6), op: Mul, lhs: Relative(1), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Add, lhs: Relative(3), rhs: Relative(6) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 442 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 442 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(24) }, JumpIf { condition: Relative(3), location: 466 }, Jump { location: 445 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(6), location: 458 }, Jump { location: 448 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(5), location: 452 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(32) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 456 }, Call { location: 499 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 464 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 462 }, Call { location: 499 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 464 }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 468 }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 468 }, Load { destination: Relative(2), source_pointer: Relative(33) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 474 }, Call { location: 502 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 484 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 495 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 488 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 477 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, Const { destination: Relative(7), bit_size: Field, value: 8 }, Const { destination: Relative(8), bit_size: Field, value: 9 }, Const { destination: Relative(9), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 59 }, Jump { location: 25 }, JumpIf { condition: Relative(6), location: 55 }, Jump { location: 27 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 55 }, 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: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, Mov { destination: Relative(6), source: Relative(5) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(6) }, Mov { destination: Direct(32773), source: Relative(8) }, Call { location: 483 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(5), size: Relative(4) } }, Mov { destination: Relative(11), source: Relative(8) }, Jump { location: 57 }, Mov { destination: Relative(2), source: Relative(11) }, Jump { location: 61 }, Mov { destination: Relative(2), source: Relative(7) }, Jump { location: 61 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(26), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(28), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(11), location: 169 }, Jump { location: 82 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 91 }, Jump { location: 85 }, Const { destination: Relative(8), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 90 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 243 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(29) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(30), source: Relative(29) }, Store { destination_pointer: Relative(30), source: Relative(2) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(8) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(25) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(29), source: Relative(8) }, Store { destination_pointer: Relative(29), source: Relative(13) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(15) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(17) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(19) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(21) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(23) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(25) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(7) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(27) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(8), size: 3 }), HeapArray(HeapArray { pointer: Relative(24), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 243 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Relative(29), source: Relative(11) }, Store { destination_pointer: Relative(29), source: Relative(13) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(15) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(17) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(19) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(21) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(23) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(25) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(7) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(26) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(27) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(11), size: 2 }), HeapArray(HeapArray { pointer: Relative(24), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 243 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 247 }, Call { location: 494 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Const { destination: Relative(24), bit_size: Field, value: 4 }, Const { destination: Relative(29), bit_size: Field, value: 5 }, Const { destination: Relative(30), bit_size: Field, value: 6 }, JumpIf { condition: Relative(11), location: 262 }, Jump { location: 253 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(31), source: Relative(11), bit_size: U1 }, Cast { destination: Relative(32), source: Relative(11), bit_size: Field }, Cast { destination: Relative(11), source: Relative(31), bit_size: Field }, BinaryFieldOp { destination: Relative(31), op: Mul, lhs: Relative(32), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(32), op: Mul, lhs: Relative(11), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(31), rhs: Relative(32) }, Mov { destination: Relative(2), source: Relative(11) }, Jump { location: 264 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 264 }, BinaryFieldOp { destination: Relative(31), op: Equals, lhs: Relative(2), rhs: Relative(24) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(31), location: 289 }, Jump { location: 268 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(33), location: 281 }, Jump { location: 271 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(33), location: 275 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(32) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 279 }, Call { location: 497 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 287 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 285 }, Call { location: 497 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 287 }, Mov { destination: Relative(11), source: Relative(31) }, Jump { location: 291 }, Mov { destination: Relative(11), source: Relative(8) }, Jump { location: 291 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(31), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(33), source: Direct(1) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(34) }, IndirectConst { destination_pointer: Relative(33), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, Mov { destination: Relative(35), source: Relative(34) }, Store { destination_pointer: Relative(35), source: Relative(13) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(15) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(8) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(19) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(22) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(20) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(22) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(21) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(23) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(31) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(20) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(7) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(28) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(26) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(27) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(11)), HeapArray(HeapArray { pointer: Relative(7), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, JumpIf { condition: Relative(4), location: 384 }, Jump { location: 376 }, Not { destination: Relative(4), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(7), source: Relative(6), bit_size: Field }, Cast { destination: Relative(6), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Mul, lhs: Relative(7), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(6), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(6), op: Add, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(6) }, Jump { location: 386 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 386 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(24) }, JumpIf { condition: Relative(6), location: 410 }, Jump { location: 389 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(7), location: 402 }, Jump { location: 392 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(7), location: 396 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(32) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 400 }, Call { location: 497 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 408 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 406 }, Call { location: 497 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 408 }, Mov { destination: Relative(4), source: Relative(6) }, Jump { location: 412 }, Mov { destination: Relative(4), source: Relative(1) }, Jump { location: 412 }, Load { destination: Relative(6), source_pointer: Relative(33) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 418 }, Call { location: 500 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(4)), HeapArray(HeapArray { pointer: Relative(6), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 426 }, Call { location: 497 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(1), location: 438 }, Jump { location: 429 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Not { destination: Relative(3), source: Relative(1), bit_size: U1 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Cast { destination: Relative(1), source: Relative(3), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(6), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(6), op: Mul, lhs: Relative(1), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Add, lhs: Relative(3), rhs: Relative(6) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 440 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 440 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(24) }, JumpIf { condition: Relative(3), location: 464 }, Jump { location: 443 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(6), location: 456 }, Jump { location: 446 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(5), location: 450 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(32) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 454 }, Call { location: 497 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 462 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 460 }, Call { location: 497 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 462 }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 466 }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 466 }, Load { destination: Relative(2), source_pointer: Relative(33) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 472 }, Call { location: 500 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 482 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 493 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 486 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tdnLbhpJFIDhd2HNoutc6uJXiaKIOCRCQtgi9kijyO+eOl39k2TRyAJ5M+dnnPqA7qLdtn9tvu2/vv74cjh9f/q5efj0a/P1fDgeDz++HJ8edy+Hp1P/v782U/wn+eZBtpuUxyibB+ujzkP6I++jjtHmodMYaQwZQ8ewMbpZ+shjlDHqGG0eNo2RxpAxdAwbYyg2FBuKDcWG4kPxofhQfCg+lNwf1e2m2hhljDpGm0ebxkhj9AWtDxvDx8hjlDHqGG0eaZqWmZYpy9Rl2jJ9mR1LcbCnQlSiLZEmIhFCKGGEE8gJOSEnZEEWZEEWZEEWZEEWZEEWZEVWZEVWZEVWZEVWZEVWZEM2ZEM2ZEM2ZEM2ZEM2ZEd2ZEd2ZEd2ZEd2ZEd25IyckTNyRs7IGTkj55A1ohJtiRJgfEqLEEoY4UQmClGJtkSNl1oiEiGEEkY4kYlCVKIt0ZAbckNuyA25ITfkhtyQ2yLLNBGJEEIJI5zIRCEqgZyQE3JCTsgJOSEn5ISckBOyIAuyIAuyIAuyIAuyIAuyIiuyIiuyIiuyIiuyIiuyIc8fvRohhBIBtohMFKISHZTUIz5EIhF5idjzovHtZiKUMMKJyz/uTyHzN6lKtCViP48IZ/4OZoQTeYnYhxLvIvbhCCcyUYhKtBEa+3BEIoRQwggnMlGISiAn5ISckBNyQk7ICTkhJ+SELMiCLMiCLMiCLMiCLMiCrMiKrMiKrMiKrMiKrMiKbMiGbMiGbMiGbMiGbMiG7MiO7MiO7MiO7MiO7MiOnJEzckbOyBk5I2fkjJyRM3JBLsgFuSDPn50W4cS4rdO4TusU92KJMMKJTBQiVqWINsJi749IRDgS4UQmyhKxZ9UjnMhEISrRlog9OyIR/R1rjlAi5Pl20olMFCLkFvea3bEpQpaIDWXxLmL7jKhEWyI2y4hExKp4X7FZRhjhRDga0ZaIrTEiEfFv4l3ESZ4jTvKIRAihhBFO9Lds8w1z3MuXt7fthrv+Ly/n/T5u+v/6MaD/cPC8O+9PL5uH0+vxuN38tzu+zv/o5/PuNM+X3bl/tR+h/elbnx38fjjuo962f1ZP60vjKj+vNbks9n9Xp/XVGpfpeXm/qqytv/LsKe5x5vX9lm5tva6vz3F65vXZ2i2v3xuvP/sN6/vHjMOXVt9/Xl9fOPqlXFabvvvZRS8nL689e73r2a+s7t+UOXZTXT12V05+bWkBmvw5+SL/AukDgRIfxnEE6rQG1I9bL5kT2O+dVg+h33sE8gcC7zoEVzZB4wi0esP1wzOrVz/9cmV5nvj45+Q3Ae+5/lwFWuXwTasXYLlyBfTKK/B2G2AcQ3e/4RQYb6D/rmX1+e/dgVI+EHjXFtY7z6FOd57Dq8Cd57D/2uvybdhWX4DeeQ7UPhC49zrUfw/BpThNtxzCXC/rV+8EtN55LboKvOdadBV4zz62dOc+vgrcu4/zdDkJ6y/g3m1o/oHA+j7+3B/tHg/nf/5Q8BbS+bD7etwvD7+/nh7/+urL/898hT80PJ+fHvffXs/7kP78taH/2PLJqm+t+ef4dXc8LG1r1eJhioct96/Wz2/xYn4D", + "debug_symbols": "tZnLbts8EEbfxessxLnwklcpisJNncKA4QRu8gM/grx7OaJO0ixkBDay6XdUZ44kckTT9svm1+7n8+8f++P9w5/N7beXzc/T/nDY//5xeLjbPu0fjv1/XzZT/JN8cys3m5RHlM2t9ahzSD/yHnVEm0OnEWmEjNARNqI7S488ooyoI9ocNo1II2SEjrARw2LDYsNiw2LD4sPiw+LD4sPiw5L7a/VmU2WEj8gjyog6os3RekHrISN0hI3wEXlEGVFHtDnSNC2ZlpQldcmuSjHUkwMZKEAF2gJpAhIggAKYE+aEOWFOmBNmwSyYBbNgFsyCWTALZsEsmBWzYlbMilkxK2bFrJgVs2I2zIbZMBtmw2yYDbNhNsyG2TE7ZsfsmB2zY3bMjtkxO+aMOWPOmDPmjDmHWQMyUIAQxjNaJiABAihggAMZKEBcagloC9QJSIAAChjgQAYKgLlibpgb5oa5YW6YG+aGuWFumNtilmkCEiCAAgY4kIECVABzwpwwJ8wJc8KcMCfMCXPCnDALZsEsmAWzYBbMglkwC2bBrJgVs2JWzIpZMStmxayY50evr44yP3ozJCCELcAABzLQhZI6xEMkEmALRM+LBtQFop8HCKAAfxz9LPNbVAYKUBeI7pX5/UsABWyB6EOJu4g+HKCAAQ5koAAVaAM0+nBAAgRQwAAHMlCACmBOmBPmhDlhTpgT5oQ5YU6YE2bBLJgFs2AWzIJZMAtmwSyYFbNiVsyKWTErZsWsmBWzYjbMhtkwG2bDbJgNs2E2zIbZMTtmx+yYHbNjdsyO2TE75ow5Y86YM+aMOWPOmDPmjDljLpgL5vnZaQEK5HlTp7FO6xTQFojeH6CAAQ5EVQooQAXaAItOVwlQwABfIHpWPUABAxzIQAEq0BaIntUckIAwz5tJBQxwIMwtoHtsii3ntEA0lMVdRPsMyEABKtAWiGaxuK9olgECKBAeDShABdoCMckWdxGTPKACbYGY5AEJEECBfss2b5c94PX1ZsOe/8fTabeLLf8/HwL6R4PH7Wl3fNrcHp8Ph5vNf9vD8/xHfx63xzmftqf+ah+h3fFXzy683x92Qa8379XTemms8nOtyVuxf6xO69Uay/Rc3teQtfozZ0+xx5nr+wZurV7X63NMz1yfrV1y/d64/uwX1NvE0Ftavf+8Xl8Y/VLeqk0/fXbRt8nLa2evV539THV/C2bspro6dmcmv7a0CJq8T77IR0H6QkGJh3GMQJ3WBPXr6iUzgX2ntDqEfu0I5C8UfGoIzjRBYwRavWD98Ez16tMvZ8rzxOOfk18k+Mz6c1bQKsM3rS7AcmYF9MoVeLtMYIyhu18wBcYN9O9WVs9/bQdK+ULBp1pYr5xDna6cw7OCK+ewf8n19jZsqxegV86B2hcKrl2H+rcOLMVpumQIc32rX90JaL1yLTor+MxadFbwmT62dGUfnxVc28d5epuE9Qu4tg3Nv1Cw3sff+9H2bn/68DPBa5hO++3Pw245vH8+3v3z6tP/j7zCzwyPp4e73a/n0y5M77819A8p36zPoDX9Hl9ux2EpN1YlDlMc9h2ftfz9NS7mLw==", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 612bbb7338d..652ca425d73 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -43,11 +43,11 @@ expression: artifact "BRILLIG CALL func 0: PREDICATE = EXPR [ (1, _1) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 21 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 26 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 20 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 25 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "nZHdisMgEIXfZa69UBPtJq9SSjDJtAhigtWFJfjuO+aHtheBZW/mqDPfHOEsMGKfHp319+kJ7XWBPljn7KNz02CinTy9LsBLETW0goFQm+hNLpt8bdKQ5MzgoLsYEAv8to5MZhPQR2h9co7Bt3FpHXrOxq8aTaAuZ4B+JKWFd+uwnDJ70fwcVY3aYc1fuPozf6l2XHBxhstzvG7qnVdc/cO+EnrnK6k/+BvdzGDDZz6CBhnItVZrpazqXAyCNb3DMlX2JD8cEF3jz3x0jtjnMA04poDF4C17qlcpmNS3XD7xCw==", + "debug_symbols": "nZHNqsMgEIXfZdYu1MT0Jq9SSjDJtAhigtULJfjuHfND20WgdDNHnfnmCGeGAbt4a427jndozjN03lhrbq0dex3M6Oh1Bp6LKKERDIRapVrltMrfKjVJSgx2ug0eMcNv68hk0h5dgMZFaxn8axuXofuk3aJBe+pyBugGUlp4NRbzKbEXzY9RVasNrvgLV1/zp2LDBRdHuDzGy7rceMXVD/aFqDa+kNUHf6Gb7o3/zEfQIAO51GKplFWZsoE3urOYp/Ke6Podomt4THtnj33yY49D9JgN3rKnepacSXVJ+RNP", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_0.snap index 612bbb7338d..652ca425d73 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_0.snap @@ -43,11 +43,11 @@ expression: artifact "BRILLIG CALL func 0: PREDICATE = EXPR [ (1, _1) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 21 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 26 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 20 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 25 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "nZHdisMgEIXfZa69UBPtJq9SSjDJtAhigtWFJfjuO+aHtheBZW/mqDPfHOEsMGKfHp319+kJ7XWBPljn7KNz02CinTy9LsBLETW0goFQm+hNLpt8bdKQ5MzgoLsYEAv8to5MZhPQR2h9co7Bt3FpHXrOxq8aTaAuZ4B+JKWFd+uwnDJ70fwcVY3aYc1fuPozf6l2XHBxhstzvG7qnVdc/cO+EnrnK6k/+BvdzGDDZz6CBhnItVZrpazqXAyCNb3DMlX2JD8cEF3jz3x0jtjnMA04poDF4C17qlcpmNS3XD7xCw==", + "debug_symbols": "nZHNqsMgEIXfZdYu1MT0Jq9SSjDJtAhigtULJfjuHfND20WgdDNHnfnmCGeGAbt4a427jndozjN03lhrbq0dex3M6Oh1Bp6LKKERDIRapVrltMrfKjVJSgx2ug0eMcNv68hk0h5dgMZFaxn8axuXofuk3aJBe+pyBugGUlp4NRbzKbEXzY9RVasNrvgLV1/zp2LDBRdHuDzGy7rceMXVD/aFqDa+kNUHf6Gb7o3/zEfQIAO51GKplFWZsoE3urOYp/Ke6Podomt4THtnj33yY49D9JgN3rKnepacSXVJ+RNP", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 612bbb7338d..652ca425d73 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -43,11 +43,11 @@ expression: artifact "BRILLIG CALL func 0: PREDICATE = EXPR [ (1, _1) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 21 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 26 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 20 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 25 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "nZHdisMgEIXfZa69UBPtJq9SSjDJtAhigtWFJfjuO+aHtheBZW/mqDPfHOEsMGKfHp319+kJ7XWBPljn7KNz02CinTy9LsBLETW0goFQm+hNLpt8bdKQ5MzgoLsYEAv8to5MZhPQR2h9co7Bt3FpHXrOxq8aTaAuZ4B+JKWFd+uwnDJ70fwcVY3aYc1fuPozf6l2XHBxhstzvG7qnVdc/cO+EnrnK6k/+BvdzGDDZz6CBhnItVZrpazqXAyCNb3DMlX2JD8cEF3jz3x0jtjnMA04poDF4C17qlcpmNS3XD7xCw==", + "debug_symbols": "nZHNqsMgEIXfZdYu1MT0Jq9SSjDJtAhigtULJfjuHfND20WgdDNHnfnmCGeGAbt4a427jndozjN03lhrbq0dex3M6Oh1Bp6LKKERDIRapVrltMrfKjVJSgx2ug0eMcNv68hk0h5dgMZFaxn8axuXofuk3aJBe+pyBugGUlp4NRbzKbEXzY9RVasNrvgLV1/zp2LDBRdHuDzGy7rceMXVD/aFqDa+kNUHf6Gb7o3/zEfQIAO51GKplFWZsoE3urOYp/Ke6Podomt4THtnj33yY49D9JgN3rKnepacSXVJ+RNP", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 1f5c31ed217..b2bc743d93c 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -38,9 +38,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 26 }, JumpIf { condition: Relative(2), location: 18 }, Jump { location: 25 }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 25 }, 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: 31 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, JumpIf { condition: Relative(2), location: 19 }, Jump { location: 18 }, Return, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 25 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "dZDdCoQgEEbfZa69UKPYepWIsJpCEBPThSV899V+duuiG4/jeL6BWWHAzk+t1OO8QFWv0FmplJxaNffCyVnH1xVoOtgLKk6AlRs43cF28B1ZRAgETrt1FjHJl7g4xAiL2kGlvVIE3kL57dNihN7ohI1dSgD1EBkDR6kw3QL52/RZzVhxyBkvfnp+99mzn5f54ReU3vwmVqKX9ragkJKsFJ3Coxy97i9d9zFn51ywsXOPg7eYki5bjmfNC5KxJqRpXw==", + "debug_symbols": "dZDBCoQgEIbfZc4ezLagXiUirKYQxMR0YQnffTVrtw5d/BzH7x+YDUbs3dwJNS0r1M0GvRFSirmTy8CtWFR43YDGI6ugZgQYTcgSWEKe8ArwnsBpd9YgRvkSF4ZoblBZqJWTksCbS7d/WjVXOy03oUsJoBoDQ+AkJMabJ3+bPqt5Vh5yzsqfXtz97NkvquLwS0pvfhsqPghzW5CPSUbwXuJRTk4Nl6796LNzLlibZcDRGYxJly2Hs2EFyWnr47Qv", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_0.snap index 1f5c31ed217..b2bc743d93c 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_0.snap @@ -38,9 +38,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 26 }, JumpIf { condition: Relative(2), location: 18 }, Jump { location: 25 }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 25 }, 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: 31 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, JumpIf { condition: Relative(2), location: 19 }, Jump { location: 18 }, Return, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 25 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "dZDdCoQgEEbfZa69UKPYepWIsJpCEBPThSV899V+duuiG4/jeL6BWWHAzk+t1OO8QFWv0FmplJxaNffCyVnH1xVoOtgLKk6AlRs43cF28B1ZRAgETrt1FjHJl7g4xAiL2kGlvVIE3kL57dNihN7ohI1dSgD1EBkDR6kw3QL52/RZzVhxyBkvfnp+99mzn5f54ReU3vwmVqKX9ragkJKsFJ3Coxy97i9d9zFn51ywsXOPg7eYki5bjmfNC5KxJqRpXw==", + "debug_symbols": "dZDBCoQgEIbfZc4ezLagXiUirKYQxMR0YQnffTVrtw5d/BzH7x+YDUbs3dwJNS0r1M0GvRFSirmTy8CtWFR43YDGI6ugZgQYTcgSWEKe8ArwnsBpd9YgRvkSF4ZoblBZqJWTksCbS7d/WjVXOy03oUsJoBoDQ+AkJMabJ3+bPqt5Vh5yzsqfXtz97NkvquLwS0pvfhsqPghzW5CPSUbwXuJRTk4Nl6796LNzLlibZcDRGYxJly2Hs2EFyWnr47Qv", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 1f5c31ed217..b2bc743d93c 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -38,9 +38,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 26 }, JumpIf { condition: Relative(2), location: 18 }, Jump { location: 25 }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 25 }, 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: 31 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, JumpIf { condition: Relative(2), location: 19 }, Jump { location: 18 }, Return, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 25 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "dZDdCoQgEEbfZa69UKPYepWIsJpCEBPThSV899V+duuiG4/jeL6BWWHAzk+t1OO8QFWv0FmplJxaNffCyVnH1xVoOtgLKk6AlRs43cF28B1ZRAgETrt1FjHJl7g4xAiL2kGlvVIE3kL57dNihN7ohI1dSgD1EBkDR6kw3QL52/RZzVhxyBkvfnp+99mzn5f54ReU3vwmVqKX9ragkJKsFJ3Coxy97i9d9zFn51ywsXOPg7eYki5bjmfNC5KxJqRpXw==", + "debug_symbols": "dZDBCoQgEIbfZc4ezLagXiUirKYQxMR0YQnffTVrtw5d/BzH7x+YDUbs3dwJNS0r1M0GvRFSirmTy8CtWFR43YDGI6ugZgQYTcgSWEKe8ArwnsBpd9YgRvkSF4ZoblBZqJWTksCbS7d/WjVXOy03oUsJoBoDQ+AkJMabJ3+bPqt5Vh5yzsqfXtz97NkvquLwS0pvfhsqPghzW5CPSUbwXuJRTk4Nl6796LNzLlibZcDRGYxJly2Hs2EFyWnr47Qv", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 7608949dedf..7a18864efce 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -36,9 +36,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 296 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 212 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 46 }, Jump { location: 45 }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 128 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 294 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, 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: 301 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 312 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 305 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 293 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 211 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 47 }, Jump { location: 45 }, Jump { location: 46 }, Return, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 129 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 293 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, 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: 298 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 309 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 302 }, Return]" ], - "debug_symbols": "pdXLbuJAEEDRf/GahftVVc2vjKKIEGdkyTLIgZFGEf8+btclkywizWPDxZg6gIW737rn4en6/XGcX06v3f7bW/e0jNM0fn+cTsfDZTzN66tvXd8eknb7sOuSbcmh28c10SMe9Zinbim9xweKD5TkyZ7icaW4Ulwprogr4oq4Iq6IK+KKuCKuiCviirqirqgr6oq6oq6oK+qKuqKumCvmirlirpgr5oq5Yq6YK+ZKdaW6Ul2prlRXqivVlepKdaW6EvqeBhppopkWKlTpyuXW6g09DTTSRDMtVKhSvIAX8SJexIt4ES/iRbyIF+v2fwupp4FGmmimhQpVahQv42W8jJfxMl7Gy3gZL+NlvIJX8ApewSt4Ba/gFbyCV/AET/AET/AET/AET/AET/AUT/EUT/EUT/EUT/EUT/EMz/AMz/AMz/AMz/AMz/AqXrsfSmukiWZaqFClRuvW2O6LrYFGmmimhQpVahQv4LXrJK2FClVqtHrbddoaaKSJ4hme4Rme4Rlexat4Fa9dJ7nddt195X68LMPQFu4PS/m6wJ8PyzBfuv18naZd9+MwXbc3vZ4P89bLYVnP9rtumJ/XruDLOA3t2W33e7r/enT9RQynGN/Hyx/Pp6T3eS3/Ml/vXz5H+2o+fT2vkXHV9+mcPk3H/5oOfz/9sB4djuPyaVu+NWcZD0/TwOHLdT5+OHv5eb6fuW/r5+V0HJ6vy9CkD3v7+tdIfdylEB/aXrAexiq71IeHW/v0Xw==", + "debug_symbols": "pdXLbqNAEEDRf2HNAvpRVe1fGUURccgICWGL2CONIv/70NR1JllEmsfG1xjq2EZAvzXP49P1++O0vJxem8O3t+ZpneZ5+v44n47DZTot26dvTVdfojaHvm2i7Ul9cwhbgkc95il7cufxI7MfmaMnebJHPK5kV7Ir4oq4Iq6IK+KKuCKuiCviiriirqgr6oq6oq6oK+qKuqKuqCvmirlirpgr5oq5Yq6YK+aKuVJcKa4UV4orxZXiSnGluFJcKa70XUd7GmikiWYqVKnRzUtb+472NNBIE81UqFKjeAEv4AW8gBfwAl7AC3gBL5T9gutjR3saaKSJZipUqVG8hJfwEl7CS3gJL+ElvISX8DJexst4GS/jZbyMl/EyXsYTPMETPMETPMETPMETPMFTPMVTPMVTPMVTPMVTPMUzPMMzPMMzPMMzPMMzPMMrePW+yLWBRppopkKVGi17Q70/9vY00EgTzVSoUqN4PV49X1KbaKZClRot3nq+9vY0UDzDMzzDMzzDM7yCV/Dq+ZLbrW3uj+7HyzqO9cn94Vm+PeHPwzoul+awXOe5bX4M83U/6PU8LHsvw7rt7dpmXJ63buDLNI/13a39Pd19Pbr9E4ZjCO/j+Y/nY9T7vOZ/mS/3H5+CfTUfv57XwLjq+3SKn6bDf033fz/9sG0Nx2n9tC7fqrNOw9M8svlyXY4f9l5+nu977uv6eT0dx+frOlbpw+K+XRqhlDZ25aGuCftmbEOxh1v99l8=", "file_map": { "43": { "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_0.snap index 7608949dedf..7a18864efce 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_0.snap @@ -36,9 +36,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 296 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 212 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 46 }, Jump { location: 45 }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 128 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 294 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, 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: 301 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 312 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 305 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 293 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 211 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 47 }, Jump { location: 45 }, Jump { location: 46 }, Return, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 129 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 293 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, 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: 298 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 309 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 302 }, Return]" ], - "debug_symbols": "pdXLbuJAEEDRf/GahftVVc2vjKKIEGdkyTLIgZFGEf8+btclkywizWPDxZg6gIW737rn4en6/XGcX06v3f7bW/e0jNM0fn+cTsfDZTzN66tvXd8eknb7sOuSbcmh28c10SMe9Zinbim9xweKD5TkyZ7icaW4Ulwprogr4oq4Iq6IK+KKuCKuiCviirqirqgr6oq6oq6oK+qKuqKumCvmirlirpgr5oq5Yq6YK+ZKdaW6Ul2prlRXqivVlepKdaW6EvqeBhppopkWKlTpyuXW6g09DTTSRDMtVKhSvIAX8SJexIt4ES/iRbyIF+v2fwupp4FGmmimhQpVahQv42W8jJfxMl7Gy3gZL+NlvIJX8ApewSt4Ba/gFbyCV/AET/AET/AET/AET/AET/AUT/EUT/EUT/EUT/EUT/EMz/AMz/AMz/AMz/AMz/AqXrsfSmukiWZaqFClRuvW2O6LrYFGmmimhQpVahQv4LXrJK2FClVqtHrbddoaaKSJ4hme4Rme4Rlexat4Fa9dJ7nddt195X68LMPQFu4PS/m6wJ8PyzBfuv18naZd9+MwXbc3vZ4P89bLYVnP9rtumJ/XruDLOA3t2W33e7r/enT9RQynGN/Hyx/Pp6T3eS3/Ml/vXz5H+2o+fT2vkXHV9+mcPk3H/5oOfz/9sB4djuPyaVu+NWcZD0/TwOHLdT5+OHv5eb6fuW/r5+V0HJ6vy9CkD3v7+tdIfdylEB/aXrAexiq71IeHW/v0Xw==", + "debug_symbols": "pdXLbqNAEEDRf2HNAvpRVe1fGUURccgICWGL2CONIv/70NR1JllEmsfG1xjq2EZAvzXP49P1++O0vJxem8O3t+ZpneZ5+v44n47DZTot26dvTVdfojaHvm2i7Ul9cwhbgkc95il7cufxI7MfmaMnebJHPK5kV7Ir4oq4Iq6IK+KKuCKuiCviiriirqgr6oq6oq6oK+qKuqKuqCvmirlirpgr5oq5Yq6YK+aKuVJcKa4UV4orxZXiSnGluFJcKa70XUd7GmikiWYqVKnRzUtb+472NNBIE81UqFKjeAEv4AW8gBfwAl7AC3gBL5T9gutjR3saaKSJZipUqVG8hJfwEl7CS3gJL+ElvISX8DJexst4GS/jZbyMl/EyXsYTPMETPMETPMETPMETPMFTPMVTPMVTPMVTPMVTPMUzPMMzPMMzPMMzPMMzPMMrePW+yLWBRppopkKVGi17Q70/9vY00EgTzVSoUqN4PV49X1KbaKZClRot3nq+9vY0UDzDMzzDMzzDM7yCV/Dq+ZLbrW3uj+7HyzqO9cn94Vm+PeHPwzoul+awXOe5bX4M83U/6PU8LHsvw7rt7dpmXJ63buDLNI/13a39Pd19Pbr9E4ZjCO/j+Y/nY9T7vOZ/mS/3H5+CfTUfv57XwLjq+3SKn6bDf033fz/9sG0Nx2n9tC7fqrNOw9M8svlyXY4f9l5+nu977uv6eT0dx+frOlbpw+K+XRqhlDZ25aGuCftmbEOxh1v99l8=", "file_map": { "43": { "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 7608949dedf..7a18864efce 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -36,9 +36,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 296 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 212 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 46 }, Jump { location: 45 }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 128 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 294 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, 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: 301 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 312 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 305 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 293 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 211 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 47 }, Jump { location: 45 }, Jump { location: 46 }, Return, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 129 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 293 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, 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: 298 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 309 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 302 }, Return]" ], - "debug_symbols": "pdXLbuJAEEDRf/GahftVVc2vjKKIEGdkyTLIgZFGEf8+btclkywizWPDxZg6gIW737rn4en6/XGcX06v3f7bW/e0jNM0fn+cTsfDZTzN66tvXd8eknb7sOuSbcmh28c10SMe9Zinbim9xweKD5TkyZ7icaW4Ulwprogr4oq4Iq6IK+KKuCKuiCviirqirqgr6oq6oq6oK+qKuqKumCvmirlirpgr5oq5Yq6YK+ZKdaW6Ul2prlRXqivVlepKdaW6EvqeBhppopkWKlTpyuXW6g09DTTSRDMtVKhSvIAX8SJexIt4ES/iRbyIF+v2fwupp4FGmmimhQpVahQv42W8jJfxMl7Gy3gZL+NlvIJX8ApewSt4Ba/gFbyCV/AET/AET/AET/AET/AET/AUT/EUT/EUT/EUT/EUT/EMz/AMz/AMz/AMz/AMz/AqXrsfSmukiWZaqFClRuvW2O6LrYFGmmimhQpVahQv4LXrJK2FClVqtHrbddoaaKSJ4hme4Rme4Rlexat4Fa9dJ7nddt195X68LMPQFu4PS/m6wJ8PyzBfuv18naZd9+MwXbc3vZ4P89bLYVnP9rtumJ/XruDLOA3t2W33e7r/enT9RQynGN/Hyx/Pp6T3eS3/Ml/vXz5H+2o+fT2vkXHV9+mcPk3H/5oOfz/9sB4djuPyaVu+NWcZD0/TwOHLdT5+OHv5eb6fuW/r5+V0HJ6vy9CkD3v7+tdIfdylEB/aXrAexiq71IeHW/v0Xw==", + "debug_symbols": "pdXLbqNAEEDRf2HNAvpRVe1fGUURccgICWGL2CONIv/70NR1JllEmsfG1xjq2EZAvzXP49P1++O0vJxem8O3t+ZpneZ5+v44n47DZTot26dvTVdfojaHvm2i7Ul9cwhbgkc95il7cufxI7MfmaMnebJHPK5kV7Ir4oq4Iq6IK+KKuCKuiCviiriirqgr6oq6oq6oK+qKuqKuqCvmirlirpgr5oq5Yq6YK+aKuVJcKa4UV4orxZXiSnGluFJcKa70XUd7GmikiWYqVKnRzUtb+472NNBIE81UqFKjeAEv4AW8gBfwAl7AC3gBL5T9gutjR3saaKSJZipUqVG8hJfwEl7CS3gJL+ElvISX8DJexst4GS/jZbyMl/EyXsYTPMETPMETPMETPMETPMFTPMVTPMVTPMVTPMVTPMUzPMMzPMMzPMMzPMMzPMMrePW+yLWBRppopkKVGi17Q70/9vY00EgTzVSoUqN4PV49X1KbaKZClRot3nq+9vY0UDzDMzzDMzzDM7yCV/Dq+ZLbrW3uj+7HyzqO9cn94Vm+PeHPwzoul+awXOe5bX4M83U/6PU8LHsvw7rt7dpmXJ63buDLNI/13a39Pd19Pbr9E4ZjCO/j+Y/nY9T7vOZ/mS/3H5+CfTUfv57XwLjq+3SKn6bDf033fz/9sG0Nx2n9tC7fqrNOw9M8svlyXY4f9l5+nu977uv6eT0dx+frOlbpw+K+XRqhlDZ25aGuCftmbEOxh1v99l8=", "file_map": { "43": { "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index b1a9be1926a..cdab82ce182 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32859 }, 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(32858), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32858) }, Call { location: 13 }, Call { location: 37 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32859 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Field, 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: Field, value: 1 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32841), bit_size: Field, value: 2 }, Const { destination: Direct(32842), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32843), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32844), bit_size: Field, value: 4 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32846), bit_size: Field, value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 10 }, Const { destination: Direct(32852), bit_size: Field, value: 10 }, Const { destination: Direct(32853), bit_size: Field, value: 15 }, Const { destination: Direct(32854), bit_size: Integer(U32), value: 20 }, Const { destination: Direct(32855), bit_size: Field, value: 20 }, Const { destination: Direct(32856), bit_size: Field, value: 22 }, Const { destination: Direct(32857), bit_size: Field, value: 30 }, Return, Call { location: 54 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 42 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32843) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 46 }, Call { location: 60 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, Mov { destination: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 63 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 59 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: 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(4) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 84 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 303 }, Jump { location: 87 }, Load { destination: Relative(3), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(4) }, 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: 95 }, Call { location: 326 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(5), location: 101 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 107 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Direct(32845) }, Mov { destination: Relative(9), source: Relative(4) }, Mov { destination: Relative(10), source: Relative(1) }, Mov { destination: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 329 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 124 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Direct(32845) }, Mov { destination: Relative(10), source: Relative(4) }, Mov { destination: Relative(11), source: Relative(1) }, Mov { destination: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 434 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 141 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Direct(32845) }, Mov { destination: Relative(11), source: Relative(4) }, Mov { destination: Relative(12), source: Relative(1) }, Mov { destination: Relative(13), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 530 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 158 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(10), location: 164 }, Call { location: 748 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, Mov { destination: Relative(15), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(10) }, Call { location: 751 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(3) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 179 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 866 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Field, value: 3 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Direct(32836) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32839) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32841) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32844) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Relative(11) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 915 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(3) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 218 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Direct(32845) }, Mov { destination: Relative(14), source: Relative(4) }, Mov { destination: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 959 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 234 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 13 }, Mov { destination: Relative(13), source: Direct(0) }, Mov { destination: Relative(14), source: Direct(32845) }, Mov { destination: Relative(15), source: Relative(4) }, Mov { destination: Relative(16), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1013 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 14 }, Mov { destination: Relative(14), source: Direct(0) }, Mov { destination: Relative(15), source: Direct(32845) }, Mov { destination: Relative(16), source: Relative(4) }, Mov { destination: Relative(17), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1414 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 266 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 15 }, Mov { destination: Relative(15), source: Direct(0) }, Mov { destination: Relative(16), source: Direct(32845) }, Mov { destination: Relative(17), source: Relative(4) }, Mov { destination: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1549 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 282 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1750 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 2024 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Load { destination: Relative(4), source_pointer: Relative(5) }, Load { destination: Relative(7), source_pointer: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(7) }, 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: 311 }, Call { location: 326 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Store { destination_pointer: Relative(6), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 84 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 335 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 343 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 346 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 354 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 370 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 373 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 379 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 391 }, Jump { location: 382 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 414 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 402 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 405 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 414 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32842), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 418 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32841) }, JumpIf { condition: Relative(4), location: 424 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 427 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 433 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 440 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 448 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 451 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 459 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 475 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 478 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 484 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, JumpIf { condition: Relative(2), location: 496 }, Jump { location: 487 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 519 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 507 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 510 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 519 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 523 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 529 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 538 }, Call { location: 2285 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 546 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 549 }, Call { location: 2285 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 557 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 574 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 577 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 583 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 596 }, Jump { location: 586 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Jump { location: 675 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(7), location: 618 }, Jump { location: 608 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 675 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 658 }, Jump { location: 621 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 634 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 651 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 657 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 663 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Direct(32841), rhs: Direct(32856) }, JumpIf { condition: Relative(1), location: 662 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 663 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 668 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 674 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 675 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 680 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32852) }, JumpIf { condition: Relative(4), location: 686 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 692 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 698 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 704 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(7), location: 712 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 718 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 735 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 741 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 747 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 757 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 765 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 768 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32841) }, JumpIf { condition: Relative(7), location: 776 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 792 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 795 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 801 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 814 }, Jump { location: 805 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(4), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Jump { location: 856 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(2), location: 847 }, Jump { location: 825 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32843) }, JumpIf { condition: Relative(2), location: 828 }, Jump { location: 837 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32846) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 837 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 840 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 846 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 856 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 856 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 859 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 865 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 885 }, Jump { location: 874 }, JumpIf { condition: Relative(6), location: 876 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 884 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 904 }, JumpIf { condition: Relative(6), location: 887 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 895 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 904 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 908 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 914 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 933 }, Jump { location: 923 }, JumpIf { condition: Relative(5), location: 925 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(4), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 932 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 951 }, JumpIf { condition: Relative(5), location: 935 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(4), rhs: Direct(32844) }, JumpIf { condition: Relative(5), location: 942 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2314 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Store { destination_pointer: Relative(6), source: Direct(32841) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 951 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32841) }, JumpIf { condition: Relative(1), location: 958 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 991 }, Jump { location: 967 }, JumpIf { condition: Relative(6), location: 969 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 977 }, 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: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Sub, lhs: Relative(5), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 1002 }, JumpIf { condition: Relative(6), location: 993 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 1001 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 1002 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1006 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 1012 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1052 }, Jump { location: 1024 }, JumpIf { condition: Relative(7), location: 1026 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(3), location: 1034 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1040 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1393 }, JumpIf { condition: Relative(7), location: 1054 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1062 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1075 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1087 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(8) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Load { destination: Relative(6), source_pointer: Relative(1) }, 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: 1100 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1106 }, Call { location: 60 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1109 }, Call { location: 2285 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(9), rhs: Direct(32852) }, JumpIf { condition: Relative(6), location: 1117 }, 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(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1123 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1129 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Load { destination: Relative(2), source_pointer: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1149 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(2), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2336 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 1162 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32842) }, Load { destination: Relative(1), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(12), location: 1168 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1174 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1180 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(10), location: 1186 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1192 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2336 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Store { destination_pointer: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 1205 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, Load { destination: Relative(11), source_pointer: Relative(14) }, BinaryFieldOp { destination: Relative(14), op: Equals, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(14), location: 1211 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1217 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, JumpIf { condition: Relative(11), location: 1223 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32850) }, Load { destination: Relative(11), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(11), rhs: Direct(32857) }, JumpIf { condition: Relative(12), location: 1229 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1235 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Load { destination: Relative(16), source_pointer: Relative(17) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(16), rhs: Direct(32852) }, JumpIf { condition: Relative(13), location: 1256 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1262 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(13), location: 1268 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(20) }, Load { destination: Relative(13), source_pointer: Relative(19) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2428 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1280 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(18) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1286 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1292 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Direct(32840), rhs: Relative(3) }, JumpIf { condition: Relative(11), location: 1296 }, Call { location: 60 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(11), location: 1299 }, Call { location: 2285 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(19), rhs: Relative(1) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Mov { destination: Direct(32772), source: Relative(19) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2470 }, Mov { destination: Relative(15), source: Direct(32774) }, Mov { destination: Relative(20), source: Direct(32775) }, Store { destination_pointer: Relative(20), source: Direct(32855) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1312 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32845) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(18), location: 1318 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32847), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1321 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(18), location: 1327 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1333 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1339 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1345 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(19), location: 1351 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(3), location: 1354 }, Call { location: 2285 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(20) }, Load { destination: Relative(21), source_pointer: Relative(22) }, Mov { destination: Direct(32771), source: Relative(15) }, Mov { destination: Direct(32772), source: Relative(20) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2539 }, Mov { destination: Relative(19), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1372 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(19) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(1), location: 1380 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 1386 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1392 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Jump { location: 1393 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1401 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1407 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(2), location: 1413 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1465 }, Jump { location: 1425 }, JumpIf { condition: Relative(7), location: 1427 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1435 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1453 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1485 }, JumpIf { condition: Relative(7), location: 1467 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1475 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1485 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1493 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1499 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1505 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(7), location: 1513 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1519 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1536 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 1542 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 1548 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1600 }, Jump { location: 1560 }, JumpIf { condition: Relative(7), location: 1562 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1570 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1588 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 1620 }, JumpIf { condition: Relative(7), location: 1602 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1610 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1620 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1628 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1634 }, 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(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1640 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 1648 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1651 }, Jump { location: 1671 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1659 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1671 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1679 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1694 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1700 }, 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(7) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1706 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(8), location: 1714 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1720 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(9) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1737 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, JumpIf { condition: Relative(4), location: 1743 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(1), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(4), location: 1749 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Cast { destination: Relative(9), source: Relative(3), bit_size: Field }, Const { destination: Relative(10), bit_size: Field, value: 50 }, JumpIf { condition: Relative(7), location: 1806 }, Jump { location: 1763 }, JumpIf { condition: Relative(8), location: 1765 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1778 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(2) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1794 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1838 }, JumpIf { condition: Relative(8), location: 1808 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(4), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1826 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 1838 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1846 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1863 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32849) }, JumpIf { condition: Relative(1), location: 1869 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1872 }, Jump { location: 1890 }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1878 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1890 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, 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: 1898 }, Call { location: 326 }, 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(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Store { destination_pointer: Relative(6), source: Relative(9) }, JumpIf { condition: Relative(1), location: 1929 }, Jump { location: 1911 }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 1917 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 1929 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1937 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1955 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1962 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1965 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(5), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 1973 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 1979 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(3), rhs: Direct(32857) }, JumpIf { condition: Relative(6), location: 1987 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1993 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32853) }, JumpIf { condition: Relative(1), location: 2001 }, 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(9) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2007 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 2016 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 2023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(9), source: Relative(4), bit_size: Field }, JumpIf { condition: Relative(7), location: 2126 }, Jump { location: 2036 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 2039 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32846) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2052 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(10) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 2067 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(2) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2082 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 2088 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2094 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(12), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(12) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(14) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 2109 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 2117 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 2123 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 2144 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2132 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Jump { location: 2144 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2152 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2169 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 2175 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 2178 }, Jump { location: 2196 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2184 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 2196 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2211 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Direct(32857) }, JumpIf { condition: Relative(1), location: 2217 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 2228 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2240 }, Jump { location: 2257 }, JumpIf { condition: Direct(32781), location: 2242 }, Jump { location: 2246 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2256 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2256 }, Jump { location: 2269 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2269 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2283 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2283 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2276 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2292 }, Jump { location: 2294 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2313 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2311 }, 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: 2304 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2313 }, 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: 2318 }, Jump { location: 2320 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2335 }, 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: 2332 }, 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: 2325 }, 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: 2335 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2347 }, Jump { location: 2364 }, JumpIf { condition: Direct(32781), location: 2349 }, Jump { location: 2353 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2363 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2363 }, Jump { location: 2376 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2376 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2389 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2382 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2400 }, Jump { location: 2404 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2426 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2425 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2418 }, Jump { location: 2426 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2438 }, Jump { location: 2446 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2469 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2468 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2461 }, Jump { location: 2469 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2481 }, Jump { location: 2498 }, JumpIf { condition: Direct(32782), location: 2483 }, Jump { location: 2487 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2497 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2497 }, Jump { location: 2510 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2510 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2524 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2524 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2517 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2538 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2531 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2548 }, Jump { location: 2554 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2576 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2575 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2568 }, Jump { location: 2576 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2591 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2584 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32859 }, 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(32858), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32858) }, Call { location: 13 }, Call { location: 37 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32859 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Field, 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: Field, value: 1 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32841), bit_size: Field, value: 2 }, Const { destination: Direct(32842), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32843), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32844), bit_size: Field, value: 4 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32846), bit_size: Field, value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 10 }, Const { destination: Direct(32852), bit_size: Field, value: 10 }, Const { destination: Direct(32853), bit_size: Field, value: 15 }, Const { destination: Direct(32854), bit_size: Integer(U32), value: 20 }, Const { destination: Direct(32855), bit_size: Field, value: 20 }, Const { destination: Direct(32856), bit_size: Field, value: 22 }, Const { destination: Direct(32857), bit_size: Field, value: 30 }, Return, Call { location: 54 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 42 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32843) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 46 }, Call { location: 60 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, Mov { destination: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 63 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 59 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: 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(4) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 84 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 303 }, Jump { location: 87 }, Load { destination: Relative(3), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(4) }, 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: 95 }, Call { location: 326 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(5), location: 101 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 107 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Direct(32845) }, Mov { destination: Relative(9), source: Relative(4) }, Mov { destination: Relative(10), source: Relative(1) }, Mov { destination: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 329 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 124 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Direct(32845) }, Mov { destination: Relative(10), source: Relative(4) }, Mov { destination: Relative(11), source: Relative(1) }, Mov { destination: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 434 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 141 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Direct(32845) }, Mov { destination: Relative(11), source: Relative(4) }, Mov { destination: Relative(12), source: Relative(1) }, Mov { destination: Relative(13), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 530 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 158 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(10), location: 164 }, Call { location: 747 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, Mov { destination: Relative(15), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(10) }, Call { location: 750 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(3) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 179 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 865 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Field, value: 3 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Direct(32836) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32839) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32841) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32844) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Relative(11) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 914 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(3) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 218 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Direct(32845) }, Mov { destination: Relative(14), source: Relative(4) }, Mov { destination: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 958 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 234 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 13 }, Mov { destination: Relative(13), source: Direct(0) }, Mov { destination: Relative(14), source: Direct(32845) }, Mov { destination: Relative(15), source: Relative(4) }, Mov { destination: Relative(16), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1012 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 14 }, Mov { destination: Relative(14), source: Direct(0) }, Mov { destination: Relative(15), source: Direct(32845) }, Mov { destination: Relative(16), source: Relative(4) }, Mov { destination: Relative(17), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1413 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 266 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 15 }, Mov { destination: Relative(15), source: Direct(0) }, Mov { destination: Relative(16), source: Direct(32845) }, Mov { destination: Relative(17), source: Relative(4) }, Mov { destination: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1548 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 282 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1749 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 2023 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Load { destination: Relative(4), source_pointer: Relative(5) }, Load { destination: Relative(7), source_pointer: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(7) }, 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: 311 }, Call { location: 326 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Store { destination_pointer: Relative(6), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 84 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 335 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 343 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 346 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 354 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 370 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 373 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 379 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 391 }, Jump { location: 382 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 414 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 402 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 405 }, Call { location: 2284 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 414 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32842), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 418 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32841) }, JumpIf { condition: Relative(4), location: 424 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 427 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 433 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 440 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 448 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 451 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 459 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 475 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 478 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 484 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, JumpIf { condition: Relative(2), location: 496 }, Jump { location: 487 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 519 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 507 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 510 }, Call { location: 2284 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 519 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 523 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 529 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 538 }, Call { location: 2284 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 546 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 549 }, Call { location: 2284 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 557 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 574 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 577 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 583 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 596 }, Jump { location: 586 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Jump { location: 670 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(7), location: 618 }, Jump { location: 608 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 670 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 743 }, Jump { location: 621 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 634 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 651 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 657 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 658 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 663 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 669 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 670 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 675 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32852) }, JumpIf { condition: Relative(4), location: 681 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 687 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 693 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 699 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(7), location: 707 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 713 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 730 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 736 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 742 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Return, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Direct(32841), rhs: Direct(32856) }, JumpIf { condition: Relative(1), location: 747 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 756 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 764 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 767 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32841) }, JumpIf { condition: Relative(7), location: 775 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 791 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 794 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 800 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 813 }, Jump { location: 804 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(4), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Jump { location: 855 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(2), location: 846 }, Jump { location: 824 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32843) }, JumpIf { condition: Relative(2), location: 827 }, Jump { location: 836 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32846) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 836 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 839 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 845 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 855 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 855 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 858 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 864 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 884 }, Jump { location: 873 }, JumpIf { condition: Relative(6), location: 875 }, Call { location: 2284 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 883 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 903 }, JumpIf { condition: Relative(6), location: 886 }, Call { location: 2284 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 894 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 903 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 907 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 913 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 932 }, Jump { location: 922 }, JumpIf { condition: Relative(5), location: 924 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(4), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 931 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 950 }, JumpIf { condition: Relative(5), location: 934 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(4), rhs: Direct(32844) }, JumpIf { condition: Relative(5), location: 941 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2313 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Store { destination_pointer: Relative(6), source: Direct(32841) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 950 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32841) }, JumpIf { condition: Relative(1), location: 957 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 990 }, Jump { location: 966 }, JumpIf { condition: Relative(6), location: 968 }, Call { location: 2284 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 976 }, 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: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Sub, lhs: Relative(5), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 1001 }, JumpIf { condition: Relative(6), location: 992 }, Call { location: 2284 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 1000 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 1001 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1005 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 1011 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1051 }, Jump { location: 1023 }, JumpIf { condition: Relative(7), location: 1025 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(3), location: 1033 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1039 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1392 }, JumpIf { condition: Relative(7), location: 1053 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1061 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1074 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1086 }, Call { location: 2284 }, Mov { destination: Direct(32771), source: Relative(8) }, Call { location: 2287 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Load { destination: Relative(6), source_pointer: Relative(1) }, 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: 1099 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1105 }, Call { location: 60 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1108 }, Call { location: 2284 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(9), rhs: Direct(32852) }, JumpIf { condition: Relative(6), location: 1116 }, 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(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1122 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1128 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Load { destination: Relative(2), source_pointer: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1148 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(2), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2335 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 1161 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32842) }, Load { destination: Relative(1), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(12), location: 1167 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1173 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1179 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(10), location: 1185 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1191 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2335 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Store { destination_pointer: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 1204 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, Load { destination: Relative(11), source_pointer: Relative(14) }, BinaryFieldOp { destination: Relative(14), op: Equals, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(14), location: 1210 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1216 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, JumpIf { condition: Relative(11), location: 1222 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32850) }, Load { destination: Relative(11), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(11), rhs: Direct(32857) }, JumpIf { condition: Relative(12), location: 1228 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1234 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2390 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Load { destination: Relative(16), source_pointer: Relative(17) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1249 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(16), rhs: Direct(32852) }, JumpIf { condition: Relative(13), location: 1255 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1261 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(13), location: 1267 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(20) }, Load { destination: Relative(13), source_pointer: Relative(19) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2427 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1279 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(18) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1285 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1291 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Direct(32840), rhs: Relative(3) }, JumpIf { condition: Relative(11), location: 1295 }, Call { location: 60 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(11), location: 1298 }, Call { location: 2284 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(19), rhs: Relative(1) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Mov { destination: Direct(32772), source: Relative(19) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2469 }, Mov { destination: Relative(15), source: Direct(32774) }, Mov { destination: Relative(20), source: Direct(32775) }, Store { destination_pointer: Relative(20), source: Direct(32855) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1311 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32845) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(18), location: 1317 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32847), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1320 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(18), location: 1326 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1332 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1338 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1344 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(19), location: 1350 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(3), location: 1353 }, Call { location: 2284 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(20) }, Load { destination: Relative(21), source_pointer: Relative(22) }, Mov { destination: Direct(32771), source: Relative(15) }, Mov { destination: Direct(32772), source: Relative(20) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2538 }, Mov { destination: Relative(19), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1371 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(19) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(1), location: 1379 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 1385 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1391 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Jump { location: 1392 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1400 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1406 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(2), location: 1412 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1464 }, Jump { location: 1424 }, JumpIf { condition: Relative(7), location: 1426 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1434 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1452 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1484 }, JumpIf { condition: Relative(7), location: 1466 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1474 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1484 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1492 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1498 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1504 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(7), location: 1512 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1518 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1535 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 1541 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 1547 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1599 }, Jump { location: 1559 }, JumpIf { condition: Relative(7), location: 1561 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1569 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1587 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 1619 }, JumpIf { condition: Relative(7), location: 1601 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1609 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1619 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1627 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1633 }, 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(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1639 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 1647 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1650 }, Jump { location: 1670 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1658 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1670 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1678 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1693 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1699 }, 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(7) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1705 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(8), location: 1713 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1719 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(9) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1736 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, JumpIf { condition: Relative(4), location: 1742 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(1), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(4), location: 1748 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Cast { destination: Relative(9), source: Relative(3), bit_size: Field }, Const { destination: Relative(10), bit_size: Field, value: 50 }, JumpIf { condition: Relative(7), location: 1805 }, Jump { location: 1762 }, JumpIf { condition: Relative(8), location: 1764 }, Call { location: 2284 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1777 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(2) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1793 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1837 }, JumpIf { condition: Relative(8), location: 1807 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(4), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1825 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 1837 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1845 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1862 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32849) }, JumpIf { condition: Relative(1), location: 1868 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1871 }, Jump { location: 1889 }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1877 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1889 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, 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: 1897 }, Call { location: 326 }, 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(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Store { destination_pointer: Relative(6), source: Relative(9) }, JumpIf { condition: Relative(1), location: 1928 }, Jump { location: 1910 }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 1916 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 1928 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1936 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1954 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1961 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1964 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(5), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 1972 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 1978 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(3), rhs: Direct(32857) }, JumpIf { condition: Relative(6), location: 1986 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1992 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32853) }, JumpIf { condition: Relative(1), location: 2000 }, 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(9) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2006 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 2015 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 2022 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(9), source: Relative(4), bit_size: Field }, JumpIf { condition: Relative(7), location: 2125 }, Jump { location: 2035 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 2038 }, Call { location: 2284 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32846) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2051 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(10) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 2066 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(2) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2081 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 2087 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2093 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2390 }, Mov { destination: Relative(12), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(12) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(14) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 2108 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 2116 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 2122 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 2143 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2131 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Jump { location: 2143 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2151 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2168 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 2174 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 2177 }, Jump { location: 2195 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2183 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 2195 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2390 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2210 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Direct(32857) }, JumpIf { condition: Relative(1), location: 2216 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2390 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 2227 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2239 }, Jump { location: 2256 }, JumpIf { condition: Direct(32781), location: 2241 }, Jump { location: 2245 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2255 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2255 }, Jump { location: 2268 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2268 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2282 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2282 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2275 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2291 }, Jump { location: 2293 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2312 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2310 }, 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: 2303 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2312 }, 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: 2317 }, Jump { location: 2319 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2334 }, 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: 2331 }, 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: 2324 }, 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: 2334 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2346 }, Jump { location: 2363 }, JumpIf { condition: Direct(32781), location: 2348 }, Jump { location: 2352 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2362 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2362 }, Jump { location: 2375 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2375 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2388 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2381 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2399 }, Jump { location: 2403 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2425 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2424 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2417 }, Jump { location: 2425 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2437 }, Jump { location: 2445 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2468 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2467 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2460 }, Jump { location: 2468 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2480 }, Jump { location: 2497 }, JumpIf { condition: Direct(32782), location: 2482 }, Jump { location: 2486 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2496 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2496 }, Jump { location: 2509 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2509 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2523 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2523 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2516 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2537 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2530 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2547 }, Jump { location: 2553 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2575 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2574 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2567 }, Jump { location: 2575 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2590 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2583 }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap index 8e531d3e5db..c1aef93ed98 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2073 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2079 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2079 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2050 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2085 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2088 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 434 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 434 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 427 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 433 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 434 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 439 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 445 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 451 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 457 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 463 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 472 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 478 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 496 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 502 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 509 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 517 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 523 }, Call { location: 2170 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 539 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 547 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2088 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 563 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 567 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 573 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 586 }, Jump { location: 577 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 619 }, Jump { location: 597 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 600 }, Jump { location: 609 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 609 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 612 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 618 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 628 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 631 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 637 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 645 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 664 }, Jump { location: 653 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 663 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 683 }, JumpIf { condition: Relative(29), location: 666 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 674 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 683 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 687 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 693 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 722 }, Jump { location: 714 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 721 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 738 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 729 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2173 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 738 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 745 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 753 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 785 }, Jump { location: 761 }, JumpIf { condition: Relative(29), location: 763 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 771 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 796 }, JumpIf { condition: Relative(29), location: 787 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 795 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 796 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 800 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 806 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 814 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 854 }, Jump { location: 826 }, JumpIf { condition: Relative(29), location: 828 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 836 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 842 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1196 }, JumpIf { condition: Relative(29), location: 856 }, Call { location: 2085 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 864 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 877 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 889 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 902 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 908 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 911 }, Call { location: 2085 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 919 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 925 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 931 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 951 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 964 }, Call { location: 2085 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 971 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 977 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 983 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 989 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 995 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1008 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1014 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1020 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1026 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1032 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1038 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1053 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1059 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1065 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1071 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2287 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1083 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1089 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1095 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1099 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1102 }, Call { location: 2085 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2329 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1115 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1121 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1124 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1130 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1136 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1142 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1148 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1154 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1157 }, Call { location: 2085 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2398 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1175 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1183 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1189 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1195 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1196 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1204 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1210 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1216 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1224 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1275 }, Jump { location: 1235 }, JumpIf { condition: Relative(22), location: 1237 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1245 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1263 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1295 }, JumpIf { condition: Relative(22), location: 1277 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1285 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1295 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1303 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1309 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1315 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1323 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1329 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1346 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1352 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1358 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1366 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1417 }, Jump { location: 1377 }, JumpIf { condition: Relative(27), location: 1379 }, Call { location: 2085 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1387 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1405 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1437 }, JumpIf { condition: Relative(27), location: 1419 }, Call { location: 2085 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1427 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1437 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1445 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1451 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1457 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1465 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1469 }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1477 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1497 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1512 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1518 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1524 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1532 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1538 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1555 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1561 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1567 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1575 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1632 }, Jump { location: 1590 }, JumpIf { condition: Relative(22), location: 1592 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1605 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1620 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1664 }, JumpIf { condition: Relative(22), location: 1634 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1652 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1664 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1672 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1689 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1695 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1697 }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1703 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1723 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1754 }, Jump { location: 1736 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1742 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1754 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1762 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1780 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1790 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1798 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1804 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1812 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1818 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1826 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1832 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1841 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1848 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1948 }, Jump { location: 1858 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1861 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1874 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1889 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1904 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1910 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1916 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1931 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1939 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1945 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1966 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1954 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1966 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1974 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1991 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1997 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1999 }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2005 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2032 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2038 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2049 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2058 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2078 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2092 }, Jump { location: 2094 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2113 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2111 }, 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: 2104 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2113 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2125 }, Jump { location: 2142 }, JumpIf { condition: Direct(32781), location: 2127 }, Jump { location: 2131 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2141 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2141 }, Jump { location: 2154 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2154 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2168 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2168 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2161 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2177 }, Jump { location: 2179 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2194 }, 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: 2191 }, 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: 2184 }, 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: 2194 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2206 }, Jump { location: 2223 }, JumpIf { condition: Direct(32781), location: 2208 }, Jump { location: 2212 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2222 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2222 }, Jump { location: 2235 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2235 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2248 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2241 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2259 }, Jump { location: 2263 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2285 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2284 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2277 }, Jump { location: 2285 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2297 }, Jump { location: 2305 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2328 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2327 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2320 }, Jump { location: 2328 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2340 }, Jump { location: 2357 }, JumpIf { condition: Direct(32782), location: 2342 }, Jump { location: 2346 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2356 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2356 }, Jump { location: 2369 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2369 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2383 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2383 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2376 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2397 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2390 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2407 }, Jump { location: 2413 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2435 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2434 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2427 }, Jump { location: 2435 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2450 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2443 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2072 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2078 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2078 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2049 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2084 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2084 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2087 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2087 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2084 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2084 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2087 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2084 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2084 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 429 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 429 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 2045 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 417 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 422 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 428 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 429 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 434 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 440 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 446 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 452 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 458 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 467 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 473 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 491 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 497 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 504 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 512 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 518 }, Call { location: 2169 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 523 }, Call { location: 2084 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 531 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 534 }, Call { location: 2084 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 542 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2087 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 558 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 562 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 568 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 581 }, Jump { location: 572 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 623 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 614 }, Jump { location: 592 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 595 }, Jump { location: 604 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 604 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 607 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 613 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 623 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 623 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 626 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 632 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 640 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 659 }, Jump { location: 648 }, JumpIf { condition: Relative(29), location: 650 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 658 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 678 }, JumpIf { condition: Relative(29), location: 661 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 669 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 678 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 682 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 688 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 717 }, Jump { location: 709 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 716 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 733 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 724 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2172 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 733 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 740 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 748 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 780 }, Jump { location: 756 }, JumpIf { condition: Relative(29), location: 758 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 766 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 791 }, JumpIf { condition: Relative(29), location: 782 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 790 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 791 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 795 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 801 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 809 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 849 }, Jump { location: 821 }, JumpIf { condition: Relative(29), location: 823 }, Call { location: 2084 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 831 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 837 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1191 }, JumpIf { condition: Relative(29), location: 851 }, Call { location: 2084 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 859 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 872 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 884 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 897 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 903 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 906 }, Call { location: 2084 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 914 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 920 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 926 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2087 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 946 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2194 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 959 }, Call { location: 2084 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 966 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 972 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 978 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 984 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 990 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2194 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1003 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1009 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1015 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1021 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1027 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1033 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1048 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1054 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1060 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1066 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2286 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1078 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1084 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1090 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1094 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1097 }, Call { location: 2084 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2328 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1110 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1116 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1119 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1125 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1131 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1137 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1143 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1149 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1152 }, Call { location: 2084 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2397 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1170 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1178 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1184 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1190 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1191 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1199 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1205 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1211 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1219 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1270 }, Jump { location: 1230 }, JumpIf { condition: Relative(22), location: 1232 }, Call { location: 2084 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1240 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1258 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1290 }, JumpIf { condition: Relative(22), location: 1272 }, Call { location: 2084 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1280 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1290 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1298 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1304 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1310 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1318 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1324 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1341 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1347 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1353 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1361 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1412 }, Jump { location: 1372 }, JumpIf { condition: Relative(27), location: 1374 }, Call { location: 2084 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1382 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1400 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1432 }, JumpIf { condition: Relative(27), location: 1414 }, Call { location: 2084 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1422 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1432 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1440 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1446 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1452 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1460 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1464 }, Jump { location: 1484 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1472 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1484 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1492 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1507 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1513 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1519 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1527 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1533 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1550 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1556 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1562 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1570 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1627 }, Jump { location: 1585 }, JumpIf { condition: Relative(22), location: 1587 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1600 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1615 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1659 }, JumpIf { condition: Relative(22), location: 1629 }, Call { location: 2084 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1647 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1659 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1667 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1684 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1690 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1692 }, Jump { location: 1710 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1698 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1710 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1718 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1749 }, Jump { location: 1731 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1737 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1749 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1757 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1775 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1782 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1785 }, Call { location: 2084 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1793 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1799 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1807 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1813 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1821 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1827 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1836 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1843 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1943 }, Jump { location: 1853 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1856 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1869 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1884 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1899 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1905 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1911 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1926 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1934 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1940 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1961 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1949 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1961 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1969 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1986 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1992 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1994 }, Jump { location: 2012 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2000 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2012 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2027 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2033 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2044 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(1), location: 2049 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2057 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2077 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2091 }, Jump { location: 2093 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2112 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2110 }, 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: 2103 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2112 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2124 }, Jump { location: 2141 }, JumpIf { condition: Direct(32781), location: 2126 }, Jump { location: 2130 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2140 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2140 }, Jump { location: 2153 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2153 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2167 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2167 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2160 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2176 }, Jump { location: 2178 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2193 }, 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: 2190 }, 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: 2183 }, 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: 2193 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2205 }, Jump { location: 2222 }, JumpIf { condition: Direct(32781), location: 2207 }, Jump { location: 2211 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2221 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2221 }, Jump { location: 2234 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2234 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2247 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2240 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2258 }, Jump { location: 2262 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2284 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2283 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2276 }, Jump { location: 2284 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2296 }, Jump { location: 2304 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2327 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2326 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2319 }, Jump { location: 2327 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2339 }, Jump { location: 2356 }, JumpIf { condition: Direct(32782), location: 2341 }, Jump { location: 2345 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2355 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2355 }, Jump { location: 2368 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2368 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2382 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2382 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2375 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2396 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2389 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2406 }, Jump { location: 2412 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2434 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2433 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2426 }, Jump { location: 2434 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2449 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2442 }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 8e531d3e5db..c1aef93ed98 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2073 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2079 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2079 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2050 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2085 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2088 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 434 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 434 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 427 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 433 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 434 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 439 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 445 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 451 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 457 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 463 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 472 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 478 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 496 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 502 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 509 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 517 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 523 }, Call { location: 2170 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 539 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 547 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2088 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 563 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 567 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 573 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 586 }, Jump { location: 577 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 619 }, Jump { location: 597 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 600 }, Jump { location: 609 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 609 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 612 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 618 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 628 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 631 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 637 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 645 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 664 }, Jump { location: 653 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 663 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 683 }, JumpIf { condition: Relative(29), location: 666 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 674 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 683 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 687 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 693 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 722 }, Jump { location: 714 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 721 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 738 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 729 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2173 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 738 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 745 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 753 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 785 }, Jump { location: 761 }, JumpIf { condition: Relative(29), location: 763 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 771 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 796 }, JumpIf { condition: Relative(29), location: 787 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 795 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 796 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 800 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 806 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 814 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 854 }, Jump { location: 826 }, JumpIf { condition: Relative(29), location: 828 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 836 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 842 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1196 }, JumpIf { condition: Relative(29), location: 856 }, Call { location: 2085 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 864 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 877 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 889 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 902 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 908 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 911 }, Call { location: 2085 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 919 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 925 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 931 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 951 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 964 }, Call { location: 2085 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 971 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 977 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 983 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 989 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 995 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1008 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1014 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1020 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1026 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1032 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1038 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1053 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1059 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1065 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1071 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2287 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1083 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1089 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1095 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1099 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1102 }, Call { location: 2085 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2329 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1115 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1121 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1124 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1130 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1136 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1142 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1148 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1154 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1157 }, Call { location: 2085 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2398 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1175 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1183 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1189 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1195 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1196 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1204 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1210 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1216 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1224 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1275 }, Jump { location: 1235 }, JumpIf { condition: Relative(22), location: 1237 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1245 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1263 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1295 }, JumpIf { condition: Relative(22), location: 1277 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1285 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1295 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1303 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1309 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1315 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1323 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1329 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1346 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1352 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1358 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1366 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1417 }, Jump { location: 1377 }, JumpIf { condition: Relative(27), location: 1379 }, Call { location: 2085 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1387 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1405 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1437 }, JumpIf { condition: Relative(27), location: 1419 }, Call { location: 2085 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1427 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1437 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1445 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1451 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1457 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1465 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1469 }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1477 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1497 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1512 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1518 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1524 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1532 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1538 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1555 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1561 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1567 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1575 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1632 }, Jump { location: 1590 }, JumpIf { condition: Relative(22), location: 1592 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1605 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1620 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1664 }, JumpIf { condition: Relative(22), location: 1634 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1652 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1664 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1672 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1689 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1695 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1697 }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1703 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1723 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1754 }, Jump { location: 1736 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1742 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1754 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1762 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1780 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1790 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1798 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1804 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1812 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1818 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1826 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1832 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1841 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1848 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1948 }, Jump { location: 1858 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1861 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1874 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1889 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1904 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1910 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1916 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1931 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1939 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1945 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1966 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1954 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1966 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1974 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1991 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1997 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1999 }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2005 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2032 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2038 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2049 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2058 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2078 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2092 }, Jump { location: 2094 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2113 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2111 }, 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: 2104 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2113 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2125 }, Jump { location: 2142 }, JumpIf { condition: Direct(32781), location: 2127 }, Jump { location: 2131 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2141 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2141 }, Jump { location: 2154 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2154 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2168 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2168 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2161 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2177 }, Jump { location: 2179 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2194 }, 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: 2191 }, 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: 2184 }, 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: 2194 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2206 }, Jump { location: 2223 }, JumpIf { condition: Direct(32781), location: 2208 }, Jump { location: 2212 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2222 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2222 }, Jump { location: 2235 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2235 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2248 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2241 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2259 }, Jump { location: 2263 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2285 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2284 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2277 }, Jump { location: 2285 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2297 }, Jump { location: 2305 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2328 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2327 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2320 }, Jump { location: 2328 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2340 }, Jump { location: 2357 }, JumpIf { condition: Direct(32782), location: 2342 }, Jump { location: 2346 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2356 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2356 }, Jump { location: 2369 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2369 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2383 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2383 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2376 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2397 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2390 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2407 }, Jump { location: 2413 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2435 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2434 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2427 }, Jump { location: 2435 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2450 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2443 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2072 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2078 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2078 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2049 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2084 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2084 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2087 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2087 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2084 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2084 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2087 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2084 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2084 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 429 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 429 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 2045 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 417 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 422 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 428 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 429 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 434 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 440 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 446 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 452 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 458 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 467 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 473 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 491 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 497 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 504 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 512 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 518 }, Call { location: 2169 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 523 }, Call { location: 2084 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 531 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 534 }, Call { location: 2084 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 542 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2087 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 558 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 562 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 568 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 581 }, Jump { location: 572 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 623 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 614 }, Jump { location: 592 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 595 }, Jump { location: 604 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 604 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 607 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 613 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 623 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 623 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 626 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 632 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 640 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 659 }, Jump { location: 648 }, JumpIf { condition: Relative(29), location: 650 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 658 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 678 }, JumpIf { condition: Relative(29), location: 661 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 669 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 678 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 682 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 688 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 717 }, Jump { location: 709 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 716 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 733 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 724 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2172 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 733 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 740 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 748 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 780 }, Jump { location: 756 }, JumpIf { condition: Relative(29), location: 758 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 766 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 791 }, JumpIf { condition: Relative(29), location: 782 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 790 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 791 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 795 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 801 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 809 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 849 }, Jump { location: 821 }, JumpIf { condition: Relative(29), location: 823 }, Call { location: 2084 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 831 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 837 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1191 }, JumpIf { condition: Relative(29), location: 851 }, Call { location: 2084 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 859 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 872 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 884 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 897 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 903 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 906 }, Call { location: 2084 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 914 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 920 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 926 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2087 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 946 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2194 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 959 }, Call { location: 2084 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 966 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 972 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 978 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 984 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 990 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2194 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1003 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1009 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1015 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1021 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1027 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1033 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1048 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1054 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1060 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1066 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2286 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1078 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1084 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1090 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1094 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1097 }, Call { location: 2084 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2328 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1110 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1116 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1119 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1125 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1131 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1137 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1143 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1149 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1152 }, Call { location: 2084 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2397 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1170 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1178 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1184 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1190 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1191 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1199 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1205 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1211 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1219 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1270 }, Jump { location: 1230 }, JumpIf { condition: Relative(22), location: 1232 }, Call { location: 2084 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1240 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1258 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1290 }, JumpIf { condition: Relative(22), location: 1272 }, Call { location: 2084 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1280 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1290 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1298 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1304 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1310 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1318 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1324 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1341 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1347 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1353 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1361 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1412 }, Jump { location: 1372 }, JumpIf { condition: Relative(27), location: 1374 }, Call { location: 2084 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1382 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1400 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1432 }, JumpIf { condition: Relative(27), location: 1414 }, Call { location: 2084 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1422 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1432 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1440 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1446 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1452 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1460 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1464 }, Jump { location: 1484 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1472 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1484 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1492 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1507 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1513 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1519 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1527 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1533 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1550 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1556 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1562 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1570 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1627 }, Jump { location: 1585 }, JumpIf { condition: Relative(22), location: 1587 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1600 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1615 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1659 }, JumpIf { condition: Relative(22), location: 1629 }, Call { location: 2084 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1647 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1659 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1667 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1684 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1690 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1692 }, Jump { location: 1710 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1698 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1710 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1718 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1749 }, Jump { location: 1731 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1737 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1749 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1757 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1775 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1782 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1785 }, Call { location: 2084 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1793 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1799 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1807 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1813 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1821 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1827 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1836 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1843 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1943 }, Jump { location: 1853 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1856 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1869 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1884 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1899 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1905 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1911 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1926 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1934 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1940 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1961 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1949 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1961 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1969 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1986 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1992 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1994 }, Jump { location: 2012 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2000 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2012 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2027 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2033 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2044 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(1), location: 2049 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2057 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2077 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2091 }, Jump { location: 2093 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2112 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2110 }, 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: 2103 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2112 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2124 }, Jump { location: 2141 }, JumpIf { condition: Direct(32781), location: 2126 }, Jump { location: 2130 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2140 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2140 }, Jump { location: 2153 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2153 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2167 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2167 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2160 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2176 }, Jump { location: 2178 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2193 }, 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: 2190 }, 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: 2183 }, 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: 2193 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2205 }, Jump { location: 2222 }, JumpIf { condition: Direct(32781), location: 2207 }, Jump { location: 2211 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2221 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2221 }, Jump { location: 2234 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2234 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2247 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2240 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2258 }, Jump { location: 2262 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2284 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2283 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2276 }, Jump { location: 2284 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2296 }, Jump { location: 2304 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2327 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2326 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2319 }, Jump { location: 2327 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2339 }, Jump { location: 2356 }, JumpIf { condition: Direct(32782), location: 2341 }, Jump { location: 2345 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2355 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2355 }, Jump { location: 2368 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2368 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2382 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2382 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2375 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2396 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2389 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2406 }, Jump { location: 2412 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2434 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2433 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2426 }, Jump { location: 2434 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2449 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2442 }, Return]" ], - "debug_symbols": "td3Rrt02rgbgd8l1LyxRJMV5lcGg6HQygwBBW2TaAxwUffdjUiL/9GI5qXbOTf3tJOunl2xp2bLW7u/v/vX+n7/95/sPP/375/+++9vff3/3z08fPn788J/vP/784w+/fvj5p/tPf393+X8av/tb++5dk7XRtZlrY7Hp9z/s96atTV8bWpuxNnfKuDeyNro2c20sNnStTVubvja0NmNtVgqtFFoptFJopYyVMlbKWCljpYz7BfzdO77/idybtjZ9bWhtxtrw2sja6NrMtbHYyJ2i96atTV8bWpuxNrw2sja6NnNtLDa6UnSl6J1i94bWZqwNr42sja6NH4Dr3trazmtv297eSe0+NJP2duwt763sre7t3FtbW/O8+7hZ29u+t7S3nkf3lvdW9lb3du6t591N364r0RI9QYmR4IQkNOHB7LCNdiVawpPFQYmR4IQnq0MTnjwdtuHn9UJLeLI5KHG/vF+OmbANP6EXWqInKDES9/5071J+Vi/MhG34ub3QEj3hgd0xEpyQhCeTYyZsw7tE9+b1TrHQE5QYCU5IQhP53r13dD8W3j8WesID/RB4L1nghCQ80A+K95YF2/Ae0/1YeJ9Z6AlK3Mmx5b2VvdW9nXtra+u9J7Ztb/ve0t7eeeRvy7vPgiQ0MRN3KMXgeCVaoifuYPJj4v1ogROS0MRM2EL3zkTkaImeoIQn++jqnWlBEprwZHbYhnemhZboCUqMBCc8WRyamAnb8M5E6miJnqCEJ08HJyThyeaYCR/wL/+guRIt0RM+8PsnVHxkxKeSJmbCNuKjI9ASPUEJ/wTy5vVetaCJmbAN71ULLeGB3vLeqxZGghOe7K3qvWphJjzZG9O710JL9AQlRoITksj37r1qeMt7r1poCQ/0lvdeteCB3vLerRYkoQnvrwHb8L610BI9QYmR4IQkNHEnsx9K718B718LLdETlBiJO5n9LXv/WtDETHgy+ZXIlWiJnqDESHDCk+NCRhMzYRvev5gdLdETlPBkcXBCEpqYCdvw/rXQEj3hyeoYCU5IwpOnYyZsw/vXgieboyco4ddNl4MTfu3UHJqYCdvw3iTdIQlNzIRtxGVboCV6ghIe6McirtwCmpgJ2/BOtNASPUEJf19xyek5fnS87yzYhvedhZboCUqMBCc80I+OdxDxQ+AdZKEnKDESnJCEJmbCNiyTLZMtky2TLZO9g4gfZe8gC5qYCVsY3kEWWqInKDESnJCEJmYik1smt0z2DiLmoMRIcMKvrS/HTNiG94uFzOmZ491Bm4MTkvDA7pgJDyS/l7gSLdETY52HgzjhgXEHoomZ8MD7TBj+ubPggeLoCUqMBCckoYmZsA3vMguZzJnsXUbVMRKckIQmZsI24u4n0BI9kcmSyXEf5Icy7oQCmvBkPxZxP+SIO6JAS/QEJUaCE5LQRCZrJsdVnp8JcZkX6AlKjAQnJKGJmbANy2TLZMtky2TLZMtky2TLZO9o008/72gO9o620BKe3B2UGAlPJockNDETPqpffvd7JVqiJygxEpyQhCZmwvd5+A31lWiJnvB9jpvukeCEJDTh+6wO2/Cut9ASnjwdlBgJTkhCEzPhyea3/VeiJXrC78b9DXofXOCEJPyu3I+O98EF2/A+uNASPUGJkfBkP5TeBxc0MROe7IfS++BCS/SEJ3uDex9c4IQkPNmnQ7wPLnhyzHdciZboCU/2lo+JCG9D72gLtuEdbaEleoISI+H74+3s/WthJmzD+9dCS/QEJfwW//KDEXMQV/MpmpgV6a5W6iUqjRKXpKQlS3nvsZj+aYnIJReVIne4uCQlLUUu+zTSVWqlXqLSKHFJSvuQSI9gn62iqxTBMVnVSxHsr6BR4pKUvAd5hehBAduIHhRoiZ6gxEhwQhIxEXW5ZslS3omaz0sJU2mUYlLLDwtLSUuzFHl+YOQqtVIvRbIfGOFSJPueipZmyVIayd7O2kq9RKXae+WSlLQ0S5aa1Rox3bdEufdrqi9mGrkkpUj2Y7mm/EKRbD4peZVaqZdi8s+PR3S2JS5JSUuzZFsanXKplXqJSqPEJSlpaZaiRvfp1KvUSpFHLi5JKfKGa5YsFd1yKfaUXVQapUgWl5S0NEuR7DO+0S+XWqmXqDRKXJJS7TNF8vTZ46sUyTGj3EtUGqVIbi4paWmWLBX9cqmVeolKoxQTxiEpaSmmjf1oRb9c6iXP88ktjR66xCUpRZ63RvTQJUtFD12KGn7coocuUWmUooYft+ihPlWl0UOXZslS0UOXWqmXqBTJfoyihy5Fcszxz5KloocuVQtZtVD00KVRqn2OfjniqcEs2dZcM/T+DGBN0Ydijr67qDRKXIoakaKlWbJU9MulVuolKo0Sl+JZwHBpaZYsFX11qZXifbBLSlqKFHFZKvrlUitFirqoNEpckpKWZslS0UOXWqlqjKoRPdSn4Gb00CUpaWmWLBU9dKmVeimSzcUlT/Yr+hn9cmmWLBWfoRzPklqpl6jkNXx+bUZfXZKSlmbJUtFXl1qpl6hUNbRqaNXQqqFVI/qqT9vN6KtLrdRLVBolLkUNP8Oi1y7NUtTwMyx67VIr9RKVRolLUtLSLGUNu65SK/USlaKGuLgkJS3NkqXWs7ZQ1FBXL1FplKLGdElJS7Nkqei/S63US1QaparRq0b0bp+atOjdS5aK3r3kNXzC0qJ3L1FplLgkJS15DZ/StOjdoejdS63US1QaJS5JSUtVY1QNrhpcNbhqxOevT0NZ9PMlLklJS7NkqejnS1Ejnvb2EpWixnBxSUpRw8+/6OdLlop+vtRKvUSlUeKSlKqGVo3o5z7PatHPl1qpl6KGn7HRz5eihp9N0c+XtDRLlop+vtRKvUSlUaoaVjWin/sMpUU/X7Kt+x73AhvYQQIH6JV8JvSmgAp6MZ/9vGnF6PI+A3qzgR0kcIAMCqjgBK3YUa2jWnR/n2G9SeAAGYxqa4GBglEt1g3EKLAYw8BmAztI4AAZFFBBVCNUiwHBJ19vNrCDBA6QQQEVnKAVGdUY1RjVGNUY1WJ88FnbmwIqOEErxiCx2cAOEjhAVBNUi7HCp4dvTtCKMVxsRrU4wWPA2CRwgAwKqOAEYxFI9IsYODYb2EECB8iggApOENUM1WIMmdELYxDZJHCAUS16SwwkmwpOMKp5b1nLcjYb2EECB8iggApOENUaqjVUi7HEp4fbWrCzOcCotpb4CBjVYi3PWrqzaMW1fGcxqsUqnxhLNgmMarH6J8aSzahmQQUnaMUYSzYb2EECB8ggqhGqxVjik8wtFgJtxliy2cAOEjhABgVUENUGqsVY4hPULRYIJTtIYFTrQQYFVHCCVoyxZLOBHSQQ1QTVBNUE1QTVBNUU1RTVFNUU1RTVFNUU1RTVFNViLLE412Ms2WxgBwkcIIMCKjhBVDNUi7FkRMexDhI4wLy3bM0UnGDeXrZ+XWADO0jgABmMNzSCCk7QijGA+LOKFguUktF8EiRwgAzGe6OgghO04ppJWGxgBwkcIIPx3tbKQQUnaMUYQDYbGO9tLTlkUMBYgBgLD2PF4KYVY9XgZixEbMEOEjhAX4rjzzparHVKKjjBqBbvOFYSXnGwYi3hZgcJHCCDAio4QSsKqgmqCaoJqgmqxYLDK86dWHK4qeAErRhLDzcb2EECo0SccipglNDgBK0Yq6U2o0ScBLFiapPAAeLUmDg11viwOEErrvFhsYE45WJ82ESbGdrM0GaGNrNqs1hKlWxgBwkcYFSzoIAKTtCK7QIb2EECB4hqDdVarMSNxbltgrEaN9blxrr3zQZ2kMABMiigghNENUK1WFDsj7RaLMVKEjhABgVUcIJWXGuNF1FtoNpAtYFqA9UGqg1Ui1HDn1O1WNm1GaPGZgOj2ggSGNXiLIlRY1NABeO016AV1wXGYgM7SOAAGRRQwXhvi1aMUWOzgR0kMN7bDCo4wciN0zOGis0GdjDWhMdJG0PFJoMCerW97HyCVvShIunVYkV5rCfrsYI8VpQlB8iggApO0JKxvizZwA4SOEAGBYxqIzhBK8aosdnADhI4QAajBAcnGCV84I9VaMkGdjBKaHCADApYp8boE7TiGioWG9hBAgfIINqM0GaENhtos4E2G2izgTYbaLOBNlvfS1iMalE4xodNK8b4sNnADhI4QAYFRDVGtbiq8MegLRa3Jb1aLOuPBW5JAgfo1WJ5fyx0S1oxRoLNBnaQwAEiV5Eb48PmBKOa981Y7pZsYAcJHCCDAiqIEoYShhKGEoYShhKGEoYShhIxKGxGtfUdlQtsYAcJHCCDAio4QVRrqNZQraFaQ7UYFGh9f4ZBARWcoBVjfNhsYAcJRLWOajE++OPqFivoklFNglaM8WGzgR0kcIAMCqggqhGqxVDhD6BbrK5LdpDAATIooIITtCKjGqMaoxqjGqMaoxqjWgwV/lS+xfq7pBVjqNiMahbsoFfz5+st1uIlGRQwxvVos3UpsWjFdSmx2MAOEjhABgX0av70vsUSvqQVYwDZbGAH471FD4gBZMSJGANITCTE2r4+oiVjqFj/IIaKzQiL5ouhYnOADAqo4AQtGQv/kg3sIIEDZFDAqGbBCVoxhorNBnaQwAEyKCCqNVRrqNZRraNaDBX+XL7FKsHkABkUUMEJWjGGik2UIJSI8cEf9LdYMZgUUMEo0YNRws+dWDmYbGAHCRwggwIqOEFUY1RjVGNUY1SL8cEf5bdYY5gUUMEJWnF9D3KxgR1ECUEJQQlBCUEJQQlFCUUJRYkYFDajGgcZFFDBCVoxBoXNBnaQQFSbqDZRbaLaRLWJaoZqMWpwfDk0Ro1NAgcYuRqcoCVjDWKygR0kcIDxLmZQQAUnaMUYHzYb2EECUaKhREOJhhINJTpKdJToKNFRYg0Ki1HNggIqOEErrkFhsYEdJNBzfZHETQUnaMUYCTYb2EEC/V34MocW6xaTAio4QSvGSLDZwA6iBKMEowSjBKMEo4SghKCEoMT6MvRiVOtBBgVUcIJWjJFgs4EdJBDVFNUU1RTVFNUU1SaqTVSLkcDXg7RY5pgcIIMCKjhBK8ZI4CtJWix8THaQwKjGQQYFVHCCloy1kMkGdpDAATIY1SSoYFTToBVjfNhsYAcJHCCDAiqIag3VYqjwdSYtFkgmo5oFCRwggwIqOEErxlCx2UBUI1SLS4lYixKLKZMCerVYlhLrKZNWjAFk06vF8pFYU5kkMKpRkEEBFYwrsZVrxRhAYn1JLK5MdpDAATIY7yJOmBg1FmPU2IzcOHdi1NgkcIAMCqjgBK0Yo8YmqimqKaopqimqxagRSzdiqWVyglaMUWOzgR0kcIAMotpEtYlqE9UM1WLUiDUjsfIySeAAGRRQwQlaMlZgJhvYQQIHyGBUs6CCE7RijBqbDewggQNkENUaqsWoEQtQYlHmZowamw3sIIEDZFBABVGtoxqhGqEaoRqhGqEaoRqhGqEaoRqh2kC1GDViRU2s1UwSOEAGBZygFWOo2EQJRglGCUYJRom47Ij1O7FeMzlBK8YAstnADhI4QJQQlBCUEJRQlFCUUJRQlFCUiFFjM6pRUMEJWjFGjc0GdpDAATKIahPVJqpNVDNUM1QzVItRI9YmxUrOJIMCRi7Hb225wAZ2kMABMihgvAsJTtCKMT5sNrCDBA6QQZRoKLEGBY1fOnOBDewggQNkUEAFJ4hqhGqEaoRqhGprUJhBBgVUMKpZ0IprUFhsYAcJHKBX81VTPVZrJhWcRR8U4lj6kLDQE5QYCU5IQhMzYRsxAPh6rB7LMeO4xS+3CFBiJDghCU3MhG3Er7v444/v3uXvivv+10/v3/uvivvsl8f9/fd3v/zw6f1Pv77720+/ffz43bv/+eHjb/GP/vvLDz/F9tcfPt1/ezfE+5/+dW/vwH9/+Pje9cd3ePX1+qXxdZV48T0BXC/nr3+9Txas10s7eb0/Ktuv769eT/9/r48b4Xh9f73/T6+f9Xrjg9dTz/ajcbL/xFn/ftD86vXzof3UV/OsBrxnSE4SLl+0tBLuQfLNCXKUQFcl0HxrwqCjBEYCn+2D36/shElvTjjah/hq/kq4/eYEPkro9S7a2dGMebOVcN+xH+1DdWxfGHq0Dw370MdRQq/B7X4MeLYPhH04OhbxMbsTbL4xga6js5p8Yc9OOHsXnyfQdTLOWp6S4/WR8OUOrwLuZ59tJ9wPPO0kwpfI5LsYr9vhqyNeN8RzxKhPjMH97RF6FiGI0MO9mNVBh+lbI/g62wvuNVxyp7OIJogYb484OzuZ0BaH54VoDVf3k7GzvbA6L+TwiAhhL15//DxHjDqo98PSs4iu2IuzI6LtwrXdWXP+6fKwvz1CD8beUY05Xn8C8cNNhrQave8n/0cRY155do/5+l18dUTvZxEkFTHG2yPsLIIRIYd7UZ+GN+3NEXa2F9ZGnVmvL1WfI66JCHlzRG8nEUwzj8g9Ch+2BdcVzj21eRZhdUTMjvoIXy37+v15ep1F6FURenREuNcNKfd2dkR6DVrc+awt+mcH9ToaLxjTO/cHPJ2dWnWtdpPPImgiQt4cwWdtMXod1NHHWURdPfPDBfhXR9DZqTUGV4QcRigiDnvqZxF8nZ1aXHfIfJ8YZxFcd1UsZ2/kTzdm9PYIO7jE4fpE5aNpSK5rLH49DerPPF7OY169JjLvZwAnEax1fcNPU4lfG9H7WURd37C+vkT6+gg7i8ABVTncC5xUOu3NEXa2F7MukW7yWURd39wR8uaI15dITxHSavi/Oc4ias5Bmp6dnbOusnjKWTczqVPLzvZCrvoEkfu52VlEXWXdnGfNWR+F9xHhN0e8ns56bs5ZH8hmZ3sR3/bO28uzI/KnO1R6e8Q8+RCRWYf0ZVu26+Fe/57nznPznm62owxfjJLzBfb6mdgXMuqgtoeD+rUZvurgLGNqzYlNO30vmMWxNt+e8XqS8fnYXvWo0tcZnGbgKqPPt2e8vlJ5OM8xOSfj6PWX1Otfvwf/nu/L98D1SXLfHOpZBp7t9P76M/EvZMhZRqurpd5eX3D9hQw7zMCj/Hv2+LA9Ph+/xjfIOLkZEK7LjNdPHuP3ub6ciel10z7662uEx4w+ajfud6SHGTbrPL/k7RmvJ2OeM7im9O/D+i0y+DCjHvbccddhe9SFbH94FvkXju3h+cF1BXjztE0/Hwf7N8g4eb4gdeGkD59r4+kJhdTn/NDrMOOymlVvrx+1PGfE3+6M1xf2fyFDDjNqcmg0u44yumAclYdryecMrWs4mfz2jNP3onWHcPPwvWgdl66v1xc9ZxhXxj3ff5hRl093xmF7mNaYbkanGdiP15MbX5tBT9f4Txl01RJEumgcZtS5ThefZohVhp6NQdTq8Qu1Pg8zaoqDTscPwnOLO0PfniF0mFETaNTscD/i1yitjN7pG2TYYQba4x5QDzOszo9up++lHmvdGePNGXTabwn9lk77LXG1B8n1DTIO+8uo+3t6eLb1hYz6fLmf8x32/aFYzmyH5ynX5CQ9PNL5QgbOj4dVQM8ZUvMMJOOwTWXWe5HT8UPq+vaOO9wPrRW1Nw/PMa2ndXR6nfynDDocP5S1Mk7PU63Hhjft7Rmn46nO6nN62l+m4CsAeniuz1FtOg/bY1xSqz8engg8Z3QsyOl0HWZ8NvdxOJ5+5fzJQ4LWZIE+jGH+Kw9f3pVqzT/Lw5O3x4xBNXcyxsP8y2PGGFdlPMx3fnUG02EG7inH/BYZephR4/F4WHn8nMFX7Qe/Xub0hWOL+3Tiw2NLWu+FZv8GGYdtyngv/DD+PGcoMozfnCFXO8uQeiY5hA7bVOpafYgcvpc/zUm1b5BxMrem1aDz9beJ4pepvUzgmn/R+2n1UYYQ1Vj6sIjtCxnVFvJwnn99xuvngc8Zoz4j7wdZ3yJDDjNqkeQd1w4zBvbjdb9/zoivwu/n3nZ6bOs52N1l2zfIOG3TiTa1w/Zg7AcTvz1jHLYH132t8Omx5ZonvKeA6SxD6j5fhE4z6lpfRA77vtRckuhF3yDjsE1xLyg6rsOMuge7Z8cP38vn17fH7+WrrpEfPp9mfe9pPhzX8fC8d1KtTZtP/f4pQ/AVALE2DjPqGfrNeZRxXyfUZ+3DGo+n9qzPe2uvj+l4+rzH0klVOW1PnOP20OefMxjt+fr55hfas5776MM327+QIb0y9PoGGeMwg/FeHsbz54yaP9Z2nfU3bXUvqe31M6wvZCj2Yx72lfh/euzHxtfhse0dj57H4bGNX5a3M+ZpRn1rUuk6PNep5kvvyY/D40KCDD3NwDk2rsPzFGss9OFbGn8h4/BcH+hzQ+kbZJy2h9V74cZvz+iHbcpU5zqzvj1DDtv0s3tSNntzxtN97dNn5bf4tO11djx84+ILGfX06eY8zMCorsyHGfW0Red1nWXMXqP6HIf7MWeNptMO28PQa03Oju28KDPmNeQwo2Ys7ov0cZbRWu1H63qYUV8AnO3wuEx8f2M2PWzTjhuGhycUX8ioJ5yzH57rs+O4PDyJf874ujuXx/UzWLby59f/4/7phx8/fPr+s99n9vsfnvTpww///Ph+//jv33768bO//fV/f8m/+eenDx8/fvjP9798+vnH9//67dN7T/K/e3ft//y9+/+tuDcb//juXfefrznvnxvdP4/4+3uW6z5edv/M8bPxd70P/1n8Z/89d536vH/W+Jmv+++n3D9P/5nusaCT6f2zxc/305T72F33zy124PIduB92+R+09Qf3K67Z/vGHN8H/AQ==", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index d063404837e..c769628f02b 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -54,9 +54,9 @@ expression: artifact "return value indices : [_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31]", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: [Array([Witness(1), Witness(2), Witness(3), Witness(4), Witness(5), Witness(6), Witness(7), Witness(8), Witness(9), Witness(10), Witness(11), Witness(12), Witness(13), Witness(14), Witness(15), Witness(16), Witness(17), Witness(18), Witness(19), Witness(20), Witness(21), Witness(22), Witness(23), Witness(24), Witness(25), Witness(26), Witness(27), Witness(28), Witness(29), Witness(30), Witness(31)])]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32872 }, 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(32840), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32840) }, Call { location: 19 }, Call { location: 25 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 122 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, 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(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 30 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 31 }, Return, Call { location: 133 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 50 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 44 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(2), source: Direct(32835) }, Jump { location: 55 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 107 }, Jump { location: 58 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(5) }, Not { destination: Relative(4), source: Relative(6), bit_size: U1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(6) }, Not { destination: Relative(5), source: Relative(7), bit_size: U1 }, BinaryIntOp { destination: Relative(6), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 79 }, Jump { location: 85 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 84 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Jump { location: 85 }, Load { destination: Relative(2), source_pointer: Relative(3) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 92 }, Call { location: 139 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 142 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 105 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Relative(1), source: Relative(2) }, Return, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(6), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 180 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Store { destination_pointer: Relative(9), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(7) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 55 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 132 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 125 }, 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: 138 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 133 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(4), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(3), source: Relative(4) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(4), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 256 }, Mov { destination: Relative(2), source: Direct(32835) }, Jump { location: 154 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 159 }, Jump { location: 157 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(6), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(8), location: 164 }, Call { location: 202 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 167 }, Call { location: 205 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Cast { destination: Relative(7), source: Relative(8), bit_size: Field }, Load { destination: Relative(8), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(9), op: Mul, lhs: Relative(7), rhs: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(6), rhs: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Mul, lhs: Relative(8), rhs: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(6) }, Jump { location: 154 }, 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: 184 }, Jump { location: 186 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 201 }, 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: 198 }, 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: 191 }, 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: 201 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32872 }, 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(32840), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32840) }, Call { location: 19 }, Call { location: 25 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 121 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, 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(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 30 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 31 }, Return, Call { location: 132 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 50 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 44 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(2), source: Direct(32835) }, Jump { location: 55 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 106 }, Jump { location: 58 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(5) }, Not { destination: Relative(4), source: Relative(6), bit_size: U1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(6) }, Not { destination: Relative(5), source: Relative(7), bit_size: U1 }, BinaryIntOp { destination: Relative(6), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 101 }, Jump { location: 79 }, Load { destination: Relative(2), source_pointer: Relative(3) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 86 }, Call { location: 138 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 141 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 99 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Relative(1), source: Relative(2) }, Return, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 106 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(6), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 179 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Store { destination_pointer: Relative(9), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(7) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 55 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 131 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 124 }, 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: 137 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 132 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(4), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(3), source: Relative(4) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(4), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 256 }, Mov { destination: Relative(2), source: Direct(32835) }, Jump { location: 153 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 158 }, Jump { location: 156 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(6), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(8), location: 163 }, Call { location: 201 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 166 }, Call { location: 204 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Cast { destination: Relative(7), source: Relative(8), bit_size: Field }, Load { destination: Relative(8), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(9), op: Mul, lhs: Relative(7), rhs: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(6), rhs: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Mul, lhs: Relative(8), rhs: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(6) }, Jump { location: 153 }, 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: 183 }, Jump { location: 185 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 200 }, 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: 197 }, 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: 190 }, 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: 200 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZZNbuMwDIXv4nUWIvWfqxRB4abuwIDhBG4ywKDI3Yc0SaddpAtlk+8p1nuibMnWV/c+vF3/vI7zx+mz2798dW/LOE3jn9fpdOwv42mmf786xz+Yur3fdZgFRVBXeCcAAQq8IAhitw+EJMiCIqgrghOAAAVeEASSEiQlSEqQlCApUVKipERJieSLBOqZCNQz77rkBNSzEFDgBTReJUQBjQeOmJVFSUEAuy5TEiARlKikMKDJ56CMSs6jsjL7qa7ilKBEpVdGZVJmZVFqTtWcqjlVc6rmVK6DbkCNyqTMyqKsQnDOBCdmFmjCmwgmOKWwKCaqCnAmYH0CAKj0yqCMyqTMyqKsQl4WUFkEE9FEMkFedCyKiaqCF4kIsiOw4M7Iouo/vDzQswATaMKbCCaiiWSCAwOLYqKq4OWCkQWY4GSeF68Y5JvJS0ZE1MJ40YhYS73ddp3t0tfLMgy8Sb9tW9rM534Z5ku3n6/TtOv+9tN17fR57ueVl36hq3QbhvmdSIEf4zSwuu3ubvfYCjzT1Qw+bfb40w+P/RGLjR6x3hOg/EjAxwkp8y1ZE1IO5VHCb3NIYHNI+GgOv/lLNH/JLf5a1I8uNfjRb/6Qn/NH3+KPmz/l5/y5aXyfN39o8edt/Kbn981fn6y/ttTvwTaAh5b6/Ta+z+5Jf2yZv6s2f2zZfyVsD4BkbXgDlOiSJUSXmxK82xI8tCQkZ6+RkgCbakh+qyG3JcR8T/DPJpTGGu7PorQ9i/Aw4UCt/jguP463N85axv5tGrT5cZ2P365e/p3tih2Pz8vpOLxfl4GT7mdk+nkB+qShgwMda7lFnyfweODDEDe9p2bhJn36X9Ah9Q2HG5f2Hw==", + "debug_symbols": "pZbNbuowEIXfJWsWHv+NzatUqEppehUpCiiFK11VvPudycyEdkEXZsN3THyOx7EN/ureh7frn9dx/jh9dvuXr+5tGadp/PM6nY79ZTzN9O1X5/jD524fdp1HQRHUFcEJQOAFQRAFqdtHQhagoAjqiugEIPCCIIgCSYmSEiUlSkqUlCQpSVKSpCTyJQL1zATqibsuOwH1LAQvCAIarxKSgMYDR0RlUVIQwK5DSgJPBKVXUhjQ5DEqk5LzqCxkP9VVnBKUXhmUUZmUWYlKrocmVqqwOiUovTIoo5Lz6BXUrERlEYLTgsB5E8FENJFMcEphgSaKiaoC3LoCAKD0yqCMyqTMSlTKCgLvDqgsgoloIpkgr3cs0EQxUVUksntgwZ09i2LfcB9aLOB9IgJMeBPBRDSRTHBgZIEmiglO5jfG+0YEJ/O8eOd4fvO8dURELYw3j4i11Ntt19kpfb0sw8CH9NuxpcN87pdhvnT7+TpNu+5vP13XTp/nfl556Rd6Sq9hmN+JFPgxTgOr2+7udo+twDNdzRDyZk8//fDYn3yx0ZOv9wQoPxL844SM/ErWhIyxPEr4bQ4ZbA7ZP5rDb/6SzF+wxV+L+r3LDX4fNn/E5/wptPjT5s/4nB+bxg+4+WOLH7fxm9bvm78+WX9tqT+AHYAALfWHbfyA7kl/apm/qzZ/33L+StwWgGRt+AUoyWVLSA6bEoLbEgK0JGRnPyMlg2+qIYetBmxLSHhPCM8mlMYa7mtR2tYiPkw4UKs/jsuP6+2Ns5axf5sGbX5c5+O3p5d/Z3ti1+PzcjoO79dl4KT7HZk+XgDrzjt3oGstt+gqAQEOfAfiZvDURG7SP/6Ld0B9w+HGpf0H", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n __assert_max_bit_size(self, BIT_SIZE);\n }\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = __to_le_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = __to_be_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_le_radix(self, radix)\n }\n\n fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_be_radix(self, radix)\n }\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_0.snap index 230c1c59d0a..090dea8685c 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_0.snap @@ -54,9 +54,9 @@ expression: artifact "return value indices : [_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31]", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: [Array([Witness(1), Witness(2), Witness(3), Witness(4), Witness(5), Witness(6), Witness(7), Witness(8), Witness(9), Witness(10), Witness(11), Witness(12), Witness(13), Witness(14), Witness(15), Witness(16), Witness(17), Witness(18), Witness(19), Witness(20), Witness(21), Witness(22), Witness(23), Witness(24), Witness(25), Witness(26), Witness(27), Witness(28), Witness(29), Witness(30), Witness(31)])]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32868 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 19 }, Call { location: 20 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 151 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Return, Call { location: 162 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 45 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 39 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 31 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 1 }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 53 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 136 }, Jump { location: 56 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(8) }, Not { destination: Relative(4), source: Relative(9), bit_size: U1 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, Load { destination: Relative(9), source_pointer: Relative(10) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(10) }, Not { destination: Relative(9), source: Relative(11), bit_size: U1 }, BinaryIntOp { destination: Relative(10), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 79 }, Jump { location: 85 }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 84 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Jump { location: 85 }, Load { destination: Relative(9), source_pointer: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 92 }, Call { location: 168 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(12), source: Relative(13) }, Const { destination: Relative(13), bit_size: Field, value: 256 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 105 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 115 }, Jump { location: 108 }, Load { destination: Relative(2), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 113 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Load { destination: Relative(5), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(14), location: 120 }, Call { location: 171 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(14), location: 123 }, Call { location: 174 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Cast { destination: Relative(11), source: Relative(14), bit_size: Field }, Load { destination: Relative(14), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(11), rhs: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(5), rhs: Relative(15) }, Store { destination_pointer: Relative(12), source: Relative(11) }, BinaryFieldOp { destination: Relative(5), op: Mul, lhs: Relative(14), rhs: Relative(13) }, Store { destination_pointer: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 105 }, 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(2) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 177 }, Mov { destination: Relative(10), source: Direct(32773) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(3), source: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 53 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 161 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 154 }, 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: 167 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 181 }, Jump { location: 183 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 198 }, 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: 195 }, 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: 188 }, 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: 198 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32868 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 19 }, Call { location: 20 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 150 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Return, Call { location: 161 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 45 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 39 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 31 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 1 }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 53 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 135 }, Jump { location: 56 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(8) }, Not { destination: Relative(4), source: Relative(9), bit_size: U1 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, Load { destination: Relative(9), source_pointer: Relative(10) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(10) }, Not { destination: Relative(9), source: Relative(11), bit_size: U1 }, BinaryIntOp { destination: Relative(10), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 130 }, Jump { location: 79 }, Load { destination: Relative(9), source_pointer: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 86 }, Call { location: 167 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(12), source: Relative(13) }, Const { destination: Relative(13), bit_size: Field, value: 256 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 99 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 109 }, Jump { location: 102 }, Load { destination: Relative(2), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 107 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Load { destination: Relative(5), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(14), location: 114 }, Call { location: 170 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(14), location: 117 }, Call { location: 173 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Cast { destination: Relative(11), source: Relative(14), bit_size: Field }, Load { destination: Relative(14), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(11), rhs: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(5), rhs: Relative(15) }, Store { destination_pointer: Relative(12), source: Relative(11) }, BinaryFieldOp { destination: Relative(5), op: Mul, lhs: Relative(14), rhs: Relative(13) }, Store { destination_pointer: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 99 }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 135 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, 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(2) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 176 }, Mov { destination: Relative(10), source: Direct(32773) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(3), source: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 53 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 160 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 153 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 166 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 180 }, Jump { location: 182 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 197 }, 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: 194 }, 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: 187 }, 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: 197 }, Return]" ], - "debug_symbols": "pZbLbqswEIbfhTULj29j91WqqKIprZAQiWhypKMo735mmDFJFkRHzibfb2A+X8CES/PVf55/Pobp+/DbvL1fms95GMfh52M87LvTcJjo6KUx/GOheXNtY63ACbwgCKIABUmQFziSeAIIrMAJvCAIogAFSZAXeLF4sXixeLF4sXixeLF4sQS6JBDoYCTQQSQkAalT20QjAAGpM8EJvIDUYIhRiUoSARDJBLZt0ChBSTKgNUCn9Er20eiQ62h4yShBaZVOGZRRicqkVE9WT1ZPVk9WT+b+aeY5KKMSleyjRchZCMaUACVwaeZA11rDgS62tAgApgQowZbgSijlQF1bywFLSCVkDdaUACXYEljoOPgSQgls9hywBDYHDmym5wD4oZQAOgt+MCW4EtiDHLCEVELWwI8la/i5XGiVTumVQRmVqCRjvF7bpmy7j9Pc97zr7vYh7c5jN/fTqXmbzuPYNn+68bxc9HvspoWnbqazNOp++iKS8HsYe07X9lZttkuBl24ppnmv5eGxHrbrg02l92DzzQDpwWC3DRH5xi6GiD5tGZ7NIUKZQ7Rbc3hWn0KpT1hTn5PWWxMr6q1b6z2+Vh9cTX1Y6yO+Vo9V/Ttc631NPa79V92/u/r84vhzzfgdlA3goGb8bu3fodncw3FbkPy6AhTz1hZ8qggmFkUwWKdwZlU4qFJEU7ZyimAr3iX3axmq1jJEt84Cbd1CBLwp3MuKVDuK2x1NlXfU/4/i2dYyuWwt+/hq31Gr2w/zw4frlU3z0H2OvTa/z9P+7uzp77GcKR++x/mw77/Oc8+m29cv/bwDYksv9x19jXIrQEt/NTv+9OFmtNREbsJyLZ1Ft7vy0P4B", + "debug_symbols": "pZbNbqswEIXfhTULj//dV6miiqa0QkIkosmVrqK8+51hZkiyILpyNvmOwef4B4b40nz1n+efj2H6Pvw2b++X5nMexnH4+RgP++40HCa8emkM/Vho3lzbWMtwDM8IjMhIjMwoCxyGeAQwLMMxPCMwIiMxMqMs8JziOcVziucUzymeUzyneE4J2CUg8GJE4MWEyAyMzm0TDQMYGF0QjuEZGA0GGYVJiEEASEwC2zbJCEGIYYB7kJzQCykPZ5fIh9PLRghCK3RCLwzCKExCmgeuKBdmMUIQUh4urjihFwYh+XCdYLCjNSSwpwUSXkVQEVUkFWoHHNdaEqDCqnAqvIqgIqqgQEciqygiLCV7EqCCkgMJSo4kvIogq6D3kkUS4WSnwYEKq8Kp8CooJ5GIKpKKrKIsbxbQC7oQhFbohF4YhFGIifF6bRstvI/T3PdUd3eViPV57OZ+OjVv03kc2+ZPN56XTr/Hblp46ma8i0vspy8kBn4PY0/q2t7cZtsKtM+LGZe72sOjH7b9wWYdPdhyS4D8kGC3E2Kit2BJiMnnrYRna4iga4h2aw3P/DmoP6caf8nityZW+K1b/T695g+uxh9Wf0yv+VPV+C6tfl/jT+v4Vc/vzl9enH+pmb8DLQAHNfN36/gumc0ajtsB2a87gLJsleDTiGCiRgST6iKcWSMcVEVEo6WcI9iKb8n9XoaqvQzRratItm4jQrpFuJcjcu0sbk80Vz5R/z8Rz0rLFC0t+/hp32Gr2w/zw9H1Sknz0H2OvTS/z9P+7u7p71Hv6NH3OB/2/dd57inpdv7Fn3dIsYWSdngepVYwLUSzo6MPNfFfB2KkJix98W6yuytN7R8=", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n __assert_max_bit_size(self, BIT_SIZE);\n }\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = __to_le_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = __to_be_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_le_radix(self, radix)\n }\n\n fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_be_radix(self, radix)\n }\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 230c1c59d0a..090dea8685c 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -54,9 +54,9 @@ expression: artifact "return value indices : [_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31]", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: [Array([Witness(1), Witness(2), Witness(3), Witness(4), Witness(5), Witness(6), Witness(7), Witness(8), Witness(9), Witness(10), Witness(11), Witness(12), Witness(13), Witness(14), Witness(15), Witness(16), Witness(17), Witness(18), Witness(19), Witness(20), Witness(21), Witness(22), Witness(23), Witness(24), Witness(25), Witness(26), Witness(27), Witness(28), Witness(29), Witness(30), Witness(31)])]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32868 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 19 }, Call { location: 20 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 151 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Return, Call { location: 162 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 45 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 39 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 31 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 1 }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 53 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 136 }, Jump { location: 56 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(8) }, Not { destination: Relative(4), source: Relative(9), bit_size: U1 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, Load { destination: Relative(9), source_pointer: Relative(10) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(10) }, Not { destination: Relative(9), source: Relative(11), bit_size: U1 }, BinaryIntOp { destination: Relative(10), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 79 }, Jump { location: 85 }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 84 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Jump { location: 85 }, Load { destination: Relative(9), source_pointer: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 92 }, Call { location: 168 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(12), source: Relative(13) }, Const { destination: Relative(13), bit_size: Field, value: 256 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 105 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 115 }, Jump { location: 108 }, Load { destination: Relative(2), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 113 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Load { destination: Relative(5), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(14), location: 120 }, Call { location: 171 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(14), location: 123 }, Call { location: 174 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Cast { destination: Relative(11), source: Relative(14), bit_size: Field }, Load { destination: Relative(14), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(11), rhs: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(5), rhs: Relative(15) }, Store { destination_pointer: Relative(12), source: Relative(11) }, BinaryFieldOp { destination: Relative(5), op: Mul, lhs: Relative(14), rhs: Relative(13) }, Store { destination_pointer: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 105 }, 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(2) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 177 }, Mov { destination: Relative(10), source: Direct(32773) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(3), source: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 53 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 161 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 154 }, 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: 167 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 181 }, Jump { location: 183 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 198 }, 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: 195 }, 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: 188 }, 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: 198 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32868 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 19 }, Call { location: 20 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 150 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Return, Call { location: 161 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 45 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 39 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 31 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 1 }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 53 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 135 }, Jump { location: 56 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(8) }, Not { destination: Relative(4), source: Relative(9), bit_size: U1 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, Load { destination: Relative(9), source_pointer: Relative(10) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(10) }, Not { destination: Relative(9), source: Relative(11), bit_size: U1 }, BinaryIntOp { destination: Relative(10), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 130 }, Jump { location: 79 }, Load { destination: Relative(9), source_pointer: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 86 }, Call { location: 167 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(12), source: Relative(13) }, Const { destination: Relative(13), bit_size: Field, value: 256 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 99 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 109 }, Jump { location: 102 }, Load { destination: Relative(2), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 107 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Load { destination: Relative(5), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(14), location: 114 }, Call { location: 170 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(14), location: 117 }, Call { location: 173 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Cast { destination: Relative(11), source: Relative(14), bit_size: Field }, Load { destination: Relative(14), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(11), rhs: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(5), rhs: Relative(15) }, Store { destination_pointer: Relative(12), source: Relative(11) }, BinaryFieldOp { destination: Relative(5), op: Mul, lhs: Relative(14), rhs: Relative(13) }, Store { destination_pointer: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 99 }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 135 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, 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(2) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 176 }, Mov { destination: Relative(10), source: Direct(32773) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(3), source: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 53 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 160 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 153 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 166 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 180 }, Jump { location: 182 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 197 }, 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: 194 }, 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: 187 }, 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: 197 }, Return]" ], - "debug_symbols": "pZbLbqswEIbfhTULj29j91WqqKIprZAQiWhypKMo735mmDFJFkRHzibfb2A+X8CES/PVf55/Pobp+/DbvL1fms95GMfh52M87LvTcJjo6KUx/GOheXNtY63ACbwgCKIABUmQFziSeAIIrMAJvCAIogAFSZAXeLF4sXixeLF4sXixeLF4sQS6JBDoYCTQQSQkAalT20QjAAGpM8EJvIDUYIhRiUoSARDJBLZt0ChBSTKgNUCn9Er20eiQ62h4yShBaZVOGZRRicqkVE9WT1ZPVk9WT+b+aeY5KKMSleyjRchZCMaUACVwaeZA11rDgS62tAgApgQowZbgSijlQF1bywFLSCVkDdaUACXYEljoOPgSQgls9hywBDYHDmym5wD4oZQAOgt+MCW4EtiDHLCEVELWwI8la/i5XGiVTumVQRmVqCRjvF7bpmy7j9Pc97zr7vYh7c5jN/fTqXmbzuPYNn+68bxc9HvspoWnbqazNOp++iKS8HsYe07X9lZttkuBl24ppnmv5eGxHrbrg02l92DzzQDpwWC3DRH5xi6GiD5tGZ7NIUKZQ7Rbc3hWn0KpT1hTn5PWWxMr6q1b6z2+Vh9cTX1Y6yO+Vo9V/Ttc631NPa79V92/u/r84vhzzfgdlA3goGb8bu3fodncw3FbkPy6AhTz1hZ8qggmFkUwWKdwZlU4qFJEU7ZyimAr3iX3axmq1jJEt84Cbd1CBLwp3MuKVDuK2x1NlXfU/4/i2dYyuWwt+/hq31Gr2w/zw4frlU3z0H2OvTa/z9P+7uzp77GcKR++x/mw77/Oc8+m29cv/bwDYksv9x19jXIrQEt/NTv+9OFmtNREbsJyLZ1Ft7vy0P4B", + "debug_symbols": "pZbNbqswEIXfhTULj//dV6miiqa0QkIkosmVrqK8+51hZkiyILpyNvmOwef4B4b40nz1n+efj2H6Pvw2b++X5nMexnH4+RgP++40HCa8emkM/Vho3lzbWMtwDM8IjMhIjMwoCxyGeAQwLMMxPCMwIiMxMqMs8JziOcVziucUzymeUzyneE4J2CUg8GJE4MWEyAyMzm0TDQMYGF0QjuEZGA0GGYVJiEEASEwC2zbJCEGIYYB7kJzQCykPZ5fIh9PLRghCK3RCLwzCKExCmgeuKBdmMUIQUh4urjihFwYh+XCdYLCjNSSwpwUSXkVQEVUkFWoHHNdaEqDCqnAqvIqgIqqgQEciqygiLCV7EqCCkgMJSo4kvIogq6D3kkUS4WSnwYEKq8Kp8CooJ5GIKpKKrKIsbxbQC7oQhFbohF4YhFGIifF6bRstvI/T3PdUd3eViPV57OZ+OjVv03kc2+ZPN56XTr/Hblp46ma8i0vspy8kBn4PY0/q2t7cZtsKtM+LGZe72sOjH7b9wWYdPdhyS4D8kGC3E2Kit2BJiMnnrYRna4iga4h2aw3P/DmoP6caf8nityZW+K1b/T695g+uxh9Wf0yv+VPV+C6tfl/jT+v4Vc/vzl9enH+pmb8DLQAHNfN36/gumc0ajtsB2a87gLJsleDTiGCiRgST6iKcWSMcVEVEo6WcI9iKb8n9XoaqvQzRratItm4jQrpFuJcjcu0sbk80Vz5R/z8Rz0rLFC0t+/hp32Gr2w/zw9H1Sknz0H2OvTS/z9P+7u7p71Hv6NH3OB/2/dd57inpdv7Fn3dIsYWSdngepVYwLUSzo6MPNfFfB2KkJix98W6yuytN7R8=", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n __assert_max_bit_size(self, BIT_SIZE);\n }\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = __to_le_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = __to_be_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_le_radix(self, radix)\n }\n\n fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_be_radix(self, radix)\n }\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", From f06f04989e5e98360843b986de49e91f73faf0de Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 12:10:22 -0300 Subject: [PATCH 24/41] Fix comment --- .../src/ssa/opt/remove_unreachable_instructions.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index f674e9c88cf..1a4568004b8 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -2,7 +2,7 @@ //! For example, if an instruction in a block is `constrain u1 0 == u1 1`, //! any subsequent instructions in that block will never be executed. This pass //! then removes those subsequent instructions and replaces the block's terminator -//! values with zeroed values of the appropriate type. If the block has successors +//! with a special `unreachable` value. If the block has successors //! those successors will also be considered unreachable if they are dominated //! by that block. From 6118febca87aaa1597f7d7336ad993224babb958 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 12:11:54 -0300 Subject: [PATCH 25/41] Better handling of unreachable terminator --- compiler/noirc_evaluator/src/acir/mod.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/compiler/noirc_evaluator/src/acir/mod.rs b/compiler/noirc_evaluator/src/acir/mod.rs index 6c497aaed31..b1981438216 100644 --- a/compiler/noirc_evaluator/src/acir/mod.rs +++ b/compiler/noirc_evaluator/src/acir/mod.rs @@ -913,10 +913,9 @@ impl<'a> Context<'a> { terminator: &TerminatorInstruction, dfg: &DataFlowGraph, ) -> usize { - let no_return_values = Vec::new(); let return_values = match terminator { TerminatorInstruction::Return { return_values, .. } => return_values, - TerminatorInstruction::Unreachable { .. } => &no_return_values, + TerminatorInstruction::Unreachable { .. } => return 0, // TODO(https://github.com/noir-lang/noir/issues/4616): Enable recursion on foldable/non-inlined ACIR functions TerminatorInstruction::JmpIf { .. } | TerminatorInstruction::Jmp { .. } => { unreachable!("ICE: Program must have a singular return") @@ -934,7 +933,6 @@ impl<'a> Context<'a> { terminator: &TerminatorInstruction, dfg: &DataFlowGraph, ) -> Result<(Vec, Vec), RuntimeError> { - let no_return_values = Vec::new(); let (return_values, call_stack) = match terminator { TerminatorInstruction::Return { return_values, call_stack } => { (return_values, *call_stack) @@ -943,7 +941,7 @@ impl<'a> Context<'a> { TerminatorInstruction::JmpIf { .. } | TerminatorInstruction::Jmp { .. } => { unreachable!("ICE: Program must have a singular return") } - TerminatorInstruction::Unreachable { call_stack } => (&no_return_values, *call_stack), + TerminatorInstruction::Unreachable { .. } => return Ok((vec![], vec![])), }; let mut has_constant_return = false; From 3b0cce744202b1e509a59bace8bab564d49b26f1 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 12:19:42 -0300 Subject: [PATCH 26/41] Add another test --- .../opt/remove_unreachable_instructions.rs | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 1a4568004b8..acf76e06a88 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -458,4 +458,44 @@ mod test { } "#); } + + #[test] + fn removes_block_that_is_unreachable_when_all_of_its_predecessors_are_unreachable() { + // Here b4 won't be conisdered unreachable when we find that b2 or b3 are unreachable, + // because neither dominate it, but it will still not show up in the final SSA + // because no block will be able to reach it. + let src = r#" + acir(inline) predicate_pure fn main f0 { + b0(): + jmpif u1 0 then: b1, else: b2 + b1(): + jmp b3() + b2(): + constrain u1 0 == u1 1, "Index out of bounds" + jmp b4() + b3(): + constrain u1 0 == u1 1, "Index out of bounds" + jmp b4() + b4(): + return Field 1 + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) predicate_pure fn main f0 { + b0(): + jmpif u1 0 then: b1, else: b2 + b1(): + jmp b3() + b2(): + constrain u1 0 == u1 1, "Index out of bounds" + unreachable + b3(): + constrain u1 0 == u1 1, "Index out of bounds" + unreachable + } + "#); + } } From 216941fed312411d4a1a978811888113bda09f67 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 12:47:47 -0300 Subject: [PATCH 27/41] Remove unreachable instructions in the first SSA pass --- compiler/noirc_evaluator/src/ssa.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs index 7e0e775f716..e1bcb34703e 100644 --- a/compiler/noirc_evaluator/src/ssa.rs +++ b/compiler/noirc_evaluator/src/ssa.rs @@ -138,6 +138,7 @@ pub struct ArtifactsAndWarnings(pub Artifacts, pub Vec); /// something we take can advantage of in the [secondary_passes]. pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { vec![ + SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), SsaPass::new(Ssa::defunctionalize, "Defunctionalization"), SsaPass::new(Ssa::inline_simple_functions, "Inlining simple functions"), From 77e8e75eec89803b14de60b39e95dd8ee16b5f1c Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 12:50:15 -0300 Subject: [PATCH 28/41] Revert "Remove unreachable instructions in the first SSA pass" This reverts commit 216941fed312411d4a1a978811888113bda09f67. --- compiler/noirc_evaluator/src/ssa.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs index e1bcb34703e..7e0e775f716 100644 --- a/compiler/noirc_evaluator/src/ssa.rs +++ b/compiler/noirc_evaluator/src/ssa.rs @@ -138,7 +138,6 @@ pub struct ArtifactsAndWarnings(pub Artifacts, pub Vec); /// something we take can advantage of in the [secondary_passes]. pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { vec![ - SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), SsaPass::new(Ssa::defunctionalize, "Defunctionalization"), SsaPass::new(Ssa::inline_simple_functions, "Inlining simple functions"), From 6e4e138c825adbf90344a3d3e3e61098d04a0bf3 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 13:36:02 -0300 Subject: [PATCH 29/41] Handle unreachable during inlining with a panic --- compiler/noirc_evaluator/src/ssa/opt/inlining.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs index 1fe660d136a..6f544294462 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs @@ -727,7 +727,12 @@ impl<'function> PerFunctionContext<'function> { Some((block_id, return_values)) } - TerminatorInstruction::Unreachable { .. } => None, // Nothing to do + TerminatorInstruction::Unreachable { .. } => { + // Note: `unreachable` terminators are only added during the `remove_unreachable_instructions`, + // which runs near the end of the optimization pipeline, so never before inlining. + // If we ever want to run it before inlining we'll have to handle this case. + panic!("Unreachable terminator instruction should not exist during inlining.") + } } } } From f127e37207d170152fa5ebd15b823290c08f9c76 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 14:56:00 -0300 Subject: [PATCH 30/41] Revert "Produce unreachable terminators" This reverts commit 426f39028e4443ad0145d1708edbad1627bac509. --- .../opt/remove_unreachable_instructions.rs | 183 +++++++++--------- 1 file changed, 94 insertions(+), 89 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index acf76e06a88..a7e6b010e71 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -5,16 +5,16 @@ //! with a special `unreachable` value. If the block has successors //! those successors will also be considered unreachable if they are dominated //! by that block. +use std::sync::Arc; +use acvm::{AcirField, FieldElement}; use fxhash::FxHashSet as HashSet; +use noirc_errors::call_stack::CallStackId; use crate::ssa::{ ir::{ - basic_block::BasicBlockId, - dfg::DataFlowGraph, - dom::DominatorTree, - function::Function, - instruction::{Instruction, TerminatorInstruction}, + basic_block::BasicBlockId, dfg::DataFlowGraph, dom::DominatorTree, function::Function, + instruction::Instruction, types::Type, value::ValueId, }, ssa_gen::Ssa, }; @@ -38,7 +38,8 @@ impl Function { // Whether the current block instructions were determined to be unreachable let mut current_block_instructions_are_unreachable = false; - // Blocks that can't be reached because their dominator has an always failing instruction. + // This is the final set of blocks that we concluded have some unreachable instructions. + // At the end we'll zero out their terminators. let mut unreachable_blocks = HashSet::default(); self.simple_reachable_blocks_optimization(|context| { @@ -55,7 +56,7 @@ impl Function { } let instruction = context.instruction(); - let always_failing_instruction = match instruction { + let is_unreachable = match instruction { Instruction::Constrain(lhs, rhs, _) => { let Some(lhs_constant) = context.dfg.get_numeric_constant(*lhs) else { return; @@ -77,16 +78,22 @@ impl Function { _ => false, }; - if always_failing_instruction { + if is_unreachable { + unreachable_blocks.insert(block_id); current_block_instructions_are_unreachable = true; add_dominated_blocks(block_id, context.dfg, &mut dom, &mut unreachable_blocks); - let terminator = context.dfg[block_id].take_terminator(); - let call_stack = terminator.call_stack(); - context.dfg[block_id] - .set_terminator(TerminatorInstruction::Unreachable { call_stack }); } }); + + for block_id in unreachable_blocks { + let mut terminator = self.dfg[block_id].take_terminator(); + terminator.map_values_mut(|value_id| { + let typ = self.dfg.type_of_value(value_id); + zeroed_value(self, block_id, &typ) + }); + self.dfg[block_id].set_terminator(terminator); + } } } @@ -117,9 +124,54 @@ fn add_dominated_blocks( } } +fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> ValueId { + match typ { + Type::Numeric(numeric_type) => { + function.dfg.make_constant(FieldElement::zero(), *numeric_type) + } + Type::Array(element_types, len) => { + let mut array = im::Vector::new(); + for _ in 0..*len { + for typ in element_types.iter() { + array.push_back(zeroed_value(function, block_id, typ)); + } + } + let instruction = Instruction::MakeArray { elements: array, typ: typ.clone() }; + let stack = CallStackId::root(); + function.dfg.insert_instruction_and_results(instruction, block_id, None, stack).first() + } + Type::Slice(_) => { + let array = im::Vector::new(); + let instruction = Instruction::MakeArray { elements: array, typ: typ.clone() }; + let stack = CallStackId::root(); + function.dfg.insert_instruction_and_results(instruction, block_id, None, stack).first() + } + Type::Reference(element_type) => { + let instruction = Instruction::Allocate; + let reference_type = Type::Reference(Arc::new((**element_type).clone())); + function + .dfg + .insert_instruction_and_results( + instruction, + block_id, + Some(vec![reference_type]), + CallStackId::root(), + ) + .first() + } + Type::Function => { + // We can have the function return itself. It's fine because the terminator is unreachable anyway. + function.dfg.import_function(function.id()) + } + } +} + #[cfg(test)] mod test { - use crate::{assert_ssa_snapshot, ssa::ssa_gen::Ssa}; + use crate::{ + assert_ssa_snapshot, + ssa::{opt::assert_normalized_ssa_equals, ssa_gen::Ssa}, + }; #[test] fn removes_unreachable_instructions_in_block_for_constrain_equal() { @@ -141,7 +193,7 @@ mod test { b0(): v0 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - unreachable + return u1 0 } "#); } @@ -195,9 +247,13 @@ mod test { assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { b0(): - v0 = make_array [] : [&mut u1; 0] + v2 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - unreachable + jmp b1(u1 0) + b1(v0: u1): + jmp b2(u1 0) + b2(v1: u1): + return u1 0 } "#); } @@ -228,9 +284,13 @@ mod test { assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { b0(): - v0 = make_array [] : [&mut u1; 0] + v2 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - unreachable + jmp b2(u1 0) + b1(v0: u1): + return u1 0 + b2(v1: u1): + jmp b1(u1 0) } "#); } @@ -263,7 +323,13 @@ mod test { acir(inline) predicate_pure fn main f0 { b0(): constrain u1 0 == u1 1, "Index out of bounds" - unreachable + jmp b1() + b1(): + jmpif u1 0 then: b2, else: b3 + b2(): + jmp b1() + b3(): + return Field 0 } "#); } @@ -291,7 +357,11 @@ mod test { acir(inline) predicate_pure fn main f0 { b0(): constrain u1 0 == u1 1, "Index out of bounds" - unreachable + jmp b1() + b1(): + jmp b2() + b2(): + return Field 0 } "#); } @@ -318,24 +388,7 @@ mod test { "#; let ssa = Ssa::from_str(src).unwrap(); let ssa = ssa.remove_unreachable_instructions(); - - assert_ssa_snapshot!(ssa, @r#" - acir(inline) predicate_pure fn main f0 { - b0(): - jmp b1() - b1(): - v2 = add Field 1, Field 2 - jmp b2(v2) - b2(): - jmpif u1 0 then: b3, else: b4 - b3(): - constrain u1 0 == u1 1, "Index out of bounds" - unreachable - b4(): - v4 = add Field 1, Field 2 - return v4 - } - "#); + assert_normalized_ssa_equals(ssa, src); } #[test] @@ -357,21 +410,7 @@ mod test { "#; let ssa = Ssa::from_str(src).unwrap(); let ssa = ssa.remove_unreachable_instructions(); - - assert_ssa_snapshot!(ssa, @r#" - acir(inline) predicate_pure fn main f0 { - b0(): - jmp b1() - b1(): - jmpif u1 0 then: b2, else: b3 - b2(): - constrain u1 0 == u1 1, "Index out of bounds" - unreachable - b3(): - v3 = add Field 1, Field 2 - return v3 - } - "#); + assert_normalized_ssa_equals(ssa, src); } #[test] @@ -395,23 +434,7 @@ mod test { "#; let ssa = Ssa::from_str(src).unwrap(); let ssa = ssa.remove_unreachable_instructions(); - - assert_ssa_snapshot!(ssa, @r#" - acir(inline) predicate_pure fn main f0 { - b0(): - jmp b1() - b1(): - jmpif u1 0 then: b2, else: b3 - b2(): - constrain u1 0 == u1 1, "Index out of bounds" - unreachable - b3(): - jmp b4() - b4(): - v3 = add Field 1, Field 2 - return v3 - } - "#); + assert_normalized_ssa_equals(ssa, src); } #[test] @@ -438,25 +461,7 @@ mod test { "#; let ssa = Ssa::from_str(src).unwrap(); let ssa = ssa.remove_unreachable_instructions(); - - assert_ssa_snapshot!(ssa, @r#" - acir(inline) predicate_pure fn main f0 { - b0(): - jmp b1() - b1(): - jmpif u1 0 then: b2, else: b3 - b2(): - constrain u1 0 == u1 1, "Index out of bounds" - unreachable - b3(): - jmp b4() - b4(): - jmp b5() - b5(): - v3 = add Field 1, Field 2 - return v3 - } - "#); + assert_normalized_ssa_equals(ssa, src); } #[test] From 76d746555346d4515b6aff95deee45b14b5b7d84 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 14:57:06 -0300 Subject: [PATCH 31/41] Revert "Add an unreachable terminator" This reverts commit 9638edb3dbe1405abdd0e3a02caa57cab9f355f3. --- compiler/noirc_evaluator/src/acir/mod.rs | 10 ++-------- .../src/brillig/brillig_gen/brillig_block.rs | 3 --- .../src/ssa/function_builder/mod.rs | 6 ------ .../noirc_evaluator/src/ssa/interpreter/errors.rs | 2 -- .../noirc_evaluator/src/ssa/interpreter/mod.rs | 3 --- .../noirc_evaluator/src/ssa/ir/basic_block.rs | 5 ++--- .../noirc_evaluator/src/ssa/ir/instruction.rs | 15 +++------------ compiler/noirc_evaluator/src/ssa/ir/printer.rs | 3 --- .../src/ssa/opt/basic_conditional.rs | 3 --- .../src/ssa/opt/die/prune_dead_parameters.rs | 3 --- .../noirc_evaluator/src/ssa/opt/flatten_cfg.rs | 4 ---- compiler/noirc_evaluator/src/ssa/opt/inlining.rs | 6 ------ compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs | 2 +- .../noirc_evaluator/src/ssa/opt/simplify_cfg.rs | 5 ----- compiler/noirc_evaluator/src/ssa/opt/unrolling.rs | 4 +--- compiler/noirc_evaluator/src/ssa/parser/ast.rs | 1 - .../noirc_evaluator/src/ssa/parser/into_ssa.rs | 5 +---- compiler/noirc_evaluator/src/ssa/parser/mod.rs | 12 ------------ compiler/noirc_evaluator/src/ssa/parser/tests.rs | 11 ----------- compiler/noirc_evaluator/src/ssa/parser/token.rs | 3 --- 20 files changed, 10 insertions(+), 96 deletions(-) diff --git a/compiler/noirc_evaluator/src/acir/mod.rs b/compiler/noirc_evaluator/src/acir/mod.rs index b1981438216..7185ab7e619 100644 --- a/compiler/noirc_evaluator/src/acir/mod.rs +++ b/compiler/noirc_evaluator/src/acir/mod.rs @@ -915,11 +915,8 @@ impl<'a> Context<'a> { ) -> usize { let return_values = match terminator { TerminatorInstruction::Return { return_values, .. } => return_values, - TerminatorInstruction::Unreachable { .. } => return 0, // TODO(https://github.com/noir-lang/noir/issues/4616): Enable recursion on foldable/non-inlined ACIR functions - TerminatorInstruction::JmpIf { .. } | TerminatorInstruction::Jmp { .. } => { - unreachable!("ICE: Program must have a singular return") - } + _ => unreachable!("ICE: Program must have a singular return"), }; return_values @@ -938,10 +935,7 @@ impl<'a> Context<'a> { (return_values, *call_stack) } // TODO(https://github.com/noir-lang/noir/issues/4616): Enable recursion on foldable/non-inlined ACIR functions - TerminatorInstruction::JmpIf { .. } | TerminatorInstruction::Jmp { .. } => { - unreachable!("ICE: Program must have a singular return") - } - TerminatorInstruction::Unreachable { .. } => return Ok((vec![], vec![])), + _ => unreachable!("ICE: Program must have a singular return"), }; let mut has_constant_return = false; diff --git a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs index 479a4405932..5f3c17d0405 100644 --- a/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs +++ b/compiler/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs @@ -251,9 +251,6 @@ impl<'block, Registers: RegisterAllocator> BrilligBlock<'block, Registers> { }); self.brillig_context.codegen_return(&return_registers); } - TerminatorInstruction::Unreachable { .. } => { - // If we assume this is unreachable code then there's nothing to do here - } } } diff --git a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs index 71edf8ba21c..7a6aa468ae3 100644 --- a/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/function_builder/mod.rs @@ -442,12 +442,6 @@ impl FunctionBuilder { self.terminate_block_with(TerminatorInstruction::Return { return_values, call_stack }); } - /// Terminate the current block with an unreachable instruction - pub fn terminate_with_unreachable(&mut self) { - let call_stack = self.call_stack; - self.terminate_block_with(TerminatorInstruction::Unreachable { call_stack }); - } - /// Returns a ValueId pointing to the given function or imports the function /// into the current function if it was not already, and returns that ID. pub fn import_function(&mut self, function: FunctionId) -> ValueId { diff --git a/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs b/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs index 5870c0d4261..a0facad28dc 100644 --- a/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs +++ b/compiler/noirc_evaluator/src/ssa/interpreter/errors.rs @@ -58,8 +58,6 @@ pub enum InterpreterError { ToRadixFailed { field_id: ValueId, field: FieldElement, radix: u32 }, #[error("Failed to solve blackbox function {name}: {reason}")] BlackBoxError { name: String, reason: String }, - #[error("Reached the unreachable")] - ReachedTheUnreachable, } /// These errors can only result from interpreting malformed SSA diff --git a/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs b/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs index c7e2a47838f..cc842c9fc22 100644 --- a/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/interpreter/mod.rs @@ -262,9 +262,6 @@ impl<'ssa> Interpreter<'ssa> { break return_values; } - Some(TerminatorInstruction::Unreachable { .. }) => { - return Err(InterpreterError::ReachedTheUnreachable); - } } }; diff --git a/compiler/noirc_evaluator/src/ssa/ir/basic_block.rs b/compiler/noirc_evaluator/src/ssa/ir/basic_block.rs index a661da86c37..1bfe454ecae 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/basic_block.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/basic_block.rs @@ -149,9 +149,8 @@ impl BasicBlock { Some(TerminatorInstruction::JmpIf { then_destination, else_destination, .. }) => { vec![*then_destination, *else_destination].into_iter() } - Some(TerminatorInstruction::Return { .. }) - | Some(TerminatorInstruction::Unreachable { .. }) - | None => vec![].into_iter(), + Some(TerminatorInstruction::Return { .. }) => vec![].into_iter(), + None => vec![].into_iter(), } } } diff --git a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs index 420d150c7d3..3ec5711a79a 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/instruction.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/instruction.rs @@ -853,10 +853,6 @@ pub(crate) enum TerminatorInstruction { /// as the block arguments. Then the exit block can terminate in a return /// instruction returning these values. Return { return_values: Vec, call_stack: CallStackId }, - - /// A terminator that will never be reached because an instruction in its block - /// will always produce an assertion failure. - Unreachable { call_stack: CallStackId }, } impl TerminatorInstruction { @@ -877,7 +873,6 @@ impl TerminatorInstruction { *return_value = f(*return_value); } } - Unreachable { .. } => (), } } @@ -898,7 +893,6 @@ impl TerminatorInstruction { f(*return_value); } } - Unreachable { .. } => (), } } @@ -919,7 +913,6 @@ impl TerminatorInstruction { f(index, *return_value); } } - Unreachable { .. } => (), } } @@ -934,7 +927,7 @@ impl TerminatorInstruction { Jmp { destination, .. } => { *destination = f(*destination); } - Return { .. } | Unreachable { .. } => (), + Return { .. } => (), } } @@ -942,8 +935,7 @@ impl TerminatorInstruction { match self { TerminatorInstruction::JmpIf { call_stack, .. } | TerminatorInstruction::Jmp { call_stack, .. } - | TerminatorInstruction::Return { call_stack, .. } - | TerminatorInstruction::Unreachable { call_stack } => *call_stack, + | TerminatorInstruction::Return { call_stack, .. } => *call_stack, } } @@ -951,8 +943,7 @@ impl TerminatorInstruction { match self { TerminatorInstruction::JmpIf { call_stack, .. } | TerminatorInstruction::Jmp { call_stack, .. } - | TerminatorInstruction::Return { call_stack, .. } - | TerminatorInstruction::Unreachable { call_stack } => *call_stack = new_call_stack, + | TerminatorInstruction::Return { call_stack, .. } => *call_stack = new_call_stack, } } } diff --git a/compiler/noirc_evaluator/src/ssa/ir/printer.rs b/compiler/noirc_evaluator/src/ssa/ir/printer.rs index fe822cb7382..3c19b322a00 100644 --- a/compiler/noirc_evaluator/src/ssa/ir/printer.rs +++ b/compiler/noirc_evaluator/src/ssa/ir/printer.rs @@ -157,9 +157,6 @@ fn display_terminator( writeln!(f, " return {}", value_list(dfg, return_values)) } } - Some(TerminatorInstruction::Unreachable { .. }) => { - writeln!(f, " unreachable") - } None => writeln!(f, " (no terminator instruction)"), } } diff --git a/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs b/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs index c6763754b93..d09d3dc40c7 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/basic_conditional.rs @@ -361,9 +361,6 @@ impl Context<'_> { let return_values = vecmap(return_values, |value| self.inserter.resolve(value)); TerminatorInstruction::Return { return_values, call_stack } } - TerminatorInstruction::Unreachable { call_stack } => { - TerminatorInstruction::Unreachable { call_stack } - } }; self.inserter.function.dfg.set_block_terminator(conditional.block_entry, new_terminator); self.inserter.map_data_bus_in_place(); diff --git a/compiler/noirc_evaluator/src/ssa/opt/die/prune_dead_parameters.rs b/compiler/noirc_evaluator/src/ssa/opt/die/prune_dead_parameters.rs index e8079a9c654..af1c18206d7 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/die/prune_dead_parameters.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/die/prune_dead_parameters.rs @@ -128,9 +128,6 @@ impl Function { TerminatorInstruction::Return { .. } => { unreachable!("ICE: A return block should not be a predecessor"); } - TerminatorInstruction::Unreachable { .. } => { - unreachable!("ICE: An unreachable block should not be a predecessor"); - } } } } diff --git a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs index 3d9294e4cec..ba7b5309e9e 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/flatten_cfg.rs @@ -466,10 +466,6 @@ impl<'f> Context<'f> { self.inserter.function.dfg.set_block_terminator(target, new_return); vec![] } - TerminatorInstruction::Unreachable { .. } => { - // Nothing to do - vec![] - } } } diff --git a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs index 6f544294462..1f8060f0c3b 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/inlining.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/inlining.rs @@ -727,12 +727,6 @@ impl<'function> PerFunctionContext<'function> { Some((block_id, return_values)) } - TerminatorInstruction::Unreachable { .. } => { - // Note: `unreachable` terminators are only added during the `remove_unreachable_instructions`, - // which runs near the end of the optimization pipeline, so never before inlining. - // If we ever want to run it before inlining we'll have to handle this case. - panic!("Unreachable terminator instruction should not exist during inlining.") - } } } } diff --git a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs index 8d27fd2c38f..6ccdac3374e 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/mem2reg.rs @@ -619,7 +619,7 @@ impl<'f> PerFunctionContext<'f> { self.inserter.map_terminator_in_place(block); match self.inserter.function.dfg[block].unwrap_terminator() { - TerminatorInstruction::JmpIf { .. } | TerminatorInstruction::Unreachable { .. } => (), // Nothing to do + TerminatorInstruction::JmpIf { .. } => (), // Nothing to do TerminatorInstruction::Jmp { destination, arguments, .. } => { let destination_parameters = self.inserter.function.dfg[*destination].parameters(); assert_eq!(destination_parameters.len(), arguments.len()); diff --git a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs index bd0f0dee8ae..cf3697c683a 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/simplify_cfg.rs @@ -193,11 +193,6 @@ fn check_for_double_jmp(function: &mut Function, block: BasicBlockId, cfg: &mut TerminatorInstruction::Return { .. } => { unreachable!("ICE: predecessor block should not have return terminator instruction") } - TerminatorInstruction::Unreachable { .. } => { - unreachable!( - "ICE: predecessor block should not have unreachable terminator instruction" - ) - } }; function.dfg[predecessor_block].set_terminator(redirected_terminator_instruction); diff --git a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs index 7926f0110cd..4790aad91e6 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/unrolling.rs @@ -914,9 +914,7 @@ impl<'f> LoopIteration<'f> { } vec![*destination] } - TerminatorInstruction::Return { .. } | TerminatorInstruction::Unreachable { .. } => { - vec![] - } + TerminatorInstruction::Return { .. } => vec![], } } diff --git a/compiler/noirc_evaluator/src/ssa/parser/ast.rs b/compiler/noirc_evaluator/src/ssa/parser/ast.rs index 3f00a063b1d..40e53cc4974 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/ast.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/ast.rs @@ -180,7 +180,6 @@ pub(crate) enum ParsedTerminator { Jmp { destination: Identifier, arguments: Vec }, Jmpif { condition: ParsedValue, then_block: Identifier, else_block: Identifier }, Return(Vec), - Unreachable, } #[derive(Debug, Clone)] diff --git a/compiler/noirc_evaluator/src/ssa/parser/into_ssa.rs b/compiler/noirc_evaluator/src/ssa/parser/into_ssa.rs index a57aedae027..18c2e8a0a54 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/into_ssa.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/into_ssa.rs @@ -229,7 +229,7 @@ impl Translator { queue.push_back(self.lookup_block(then_block)?); queue.push_back(self.lookup_block(else_block)?); } - ParsedTerminator::Return(..) | ParsedTerminator::Unreachable => (), + ParsedTerminator::Return(..) => (), } } @@ -265,9 +265,6 @@ impl Translator { let return_values = self.translate_values(values)?; self.builder.terminate_with_return(return_values); } - ParsedTerminator::Unreachable => { - self.builder.terminate_with_unreachable(); - } } Ok(()) diff --git a/compiler/noirc_evaluator/src/ssa/parser/mod.rs b/compiler/noirc_evaluator/src/ssa/parser/mod.rs index 02839147b8e..d940bd22a4b 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/mod.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/mod.rs @@ -689,10 +689,6 @@ impl<'a> Parser<'a> { return Ok(terminator); } - if let Some(terminator) = self.parse_unreachable()? { - return Ok(terminator); - } - self.expected_instruction_or_terminator() } @@ -746,14 +742,6 @@ impl<'a> Parser<'a> { Ok(Some(ParsedTerminator::Jmpif { condition, then_block, else_block })) } - fn parse_unreachable(&mut self) -> ParseResult> { - if !self.eat_keyword(Keyword::Unreachable)? { - return Ok(None); - } - - Ok(Some(ParsedTerminator::Unreachable)) - } - fn parse_arguments(&mut self) -> ParseResult> { self.eat_or_error(Token::LeftParen)?; let arguments = self.parse_comma_separated_values()?; diff --git a/compiler/noirc_evaluator/src/ssa/parser/tests.rs b/compiler/noirc_evaluator/src/ssa/parser/tests.rs index a7adc24f07e..cf68edd31b5 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/tests.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/tests.rs @@ -259,17 +259,6 @@ fn test_call_no_return_value() { assert_ssa_roundtrip(src); } -#[test] -fn test_unreachable() { - let src = " - acir(inline) fn main f0 { - b0(): - unreachable - } - "; - assert_ssa_roundtrip(src); -} - #[test] fn test_call_intrinsic() { let src = " diff --git a/compiler/noirc_evaluator/src/ssa/parser/token.rs b/compiler/noirc_evaluator/src/ssa/parser/token.rs index 987f140dd89..dff169c0c5a 100644 --- a/compiler/noirc_evaluator/src/ssa/parser/token.rs +++ b/compiler/noirc_evaluator/src/ssa/parser/token.rs @@ -172,7 +172,6 @@ pub(crate) enum Keyword { UncheckedAdd, UncheckedSub, UncheckedMul, - Unreachable, Value, Xor, } @@ -239,7 +238,6 @@ impl Keyword { "unchecked_add" => Keyword::UncheckedAdd, "unchecked_sub" => Keyword::UncheckedSub, "unchecked_mul" => Keyword::UncheckedMul, - "unreachable" => Keyword::Unreachable, "value" => Keyword::Value, "xor" => Keyword::Xor, _ => return None, @@ -310,7 +308,6 @@ impl Display for Keyword { Keyword::UncheckedAdd => write!(f, "unchecked_add"), Keyword::UncheckedSub => write!(f, "unchecked_sub"), Keyword::UncheckedMul => write!(f, "unchecked_mul"), - Keyword::Unreachable => write!(f, "unreachable"), Keyword::Value => write!(f, "value"), Keyword::Xor => write!(f, "xor"), } From 97fc0ffcc861e78f7324cb0dfbde2a6ed912cc99 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 14:58:41 -0300 Subject: [PATCH 32/41] Revert "Fix comment" This reverts commit f06f04989e5e98360843b986de49e91f73faf0de. --- .../src/ssa/opt/remove_unreachable_instructions.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index a7e6b010e71..621aae44d26 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -2,7 +2,7 @@ //! For example, if an instruction in a block is `constrain u1 0 == u1 1`, //! any subsequent instructions in that block will never be executed. This pass //! then removes those subsequent instructions and replaces the block's terminator -//! with a special `unreachable` value. If the block has successors +//! values with zeroed values of the appropriate type. If the block has successors //! those successors will also be considered unreachable if they are dominated //! by that block. use std::sync::Arc; From 3a8e362152fc5776189f314104f70bf64ee350ab Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 14:58:53 -0300 Subject: [PATCH 33/41] Fix tests --- .../src/ssa/opt/remove_unreachable_instructions.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 621aae44d26..cd2096f3c0d 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -218,7 +218,7 @@ mod test { b0(): v0 = make_array [] : [&mut u1; 0] constrain u1 0 != u1 0, "Index out of bounds" - unreachable + return u1 0 } "#); } @@ -496,10 +496,12 @@ mod test { jmp b3() b2(): constrain u1 0 == u1 1, "Index out of bounds" - unreachable + jmp b4() b3(): constrain u1 0 == u1 1, "Index out of bounds" - unreachable + jmp b4() + b4(): + return Field 1 } "#); } From f72c9db2fd2682058d8784f5009fa7fb368be517 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 12:47:47 -0300 Subject: [PATCH 34/41] Remove unreachable instructions in the first SSA pass --- compiler/noirc_evaluator/src/ssa.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs index 7e0e775f716..e1bcb34703e 100644 --- a/compiler/noirc_evaluator/src/ssa.rs +++ b/compiler/noirc_evaluator/src/ssa.rs @@ -138,6 +138,7 @@ pub struct ArtifactsAndWarnings(pub Artifacts, pub Vec); /// something we take can advantage of in the [secondary_passes]. pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { vec![ + SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), SsaPass::new(Ssa::defunctionalize, "Defunctionalization"), SsaPass::new(Ssa::inline_simple_functions, "Inlining simple functions"), From 45246337701fe88d7f97416ee0715d23acf50ab2 Mon Sep 17 00:00:00 2001 From: Ary Borenszweig Date: Mon, 23 Jun 2025 16:45:28 -0300 Subject: [PATCH 35/41] Snapshots --- ...lig_true_inliner_-9223372036854775808.snap | 4 +- ...__tests__force_brillig_true_inliner_0.snap | 4 +- ...llig_true_inliner_9223372036854775807.snap | 4 +- ...lig_true_inliner_-9223372036854775808.snap | 4 +- ...__tests__force_brillig_true_inliner_0.snap | 4 +- ...llig_true_inliner_9223372036854775807.snap | 4 +- ...ig_false_inliner_-9223372036854775808.snap | 152 +++++++++--------- ..._tests__force_brillig_false_inliner_0.snap | 152 +++++++++--------- ...lig_false_inliner_9223372036854775807.snap | 152 +++++++++--------- ...lig_true_inliner_-9223372036854775808.snap | 4 +- ...__tests__force_brillig_true_inliner_0.snap | 4 +- ...llig_true_inliner_9223372036854775807.snap | 4 +- ...ig_false_inliner_-9223372036854775808.snap | 4 +- ..._tests__force_brillig_false_inliner_0.snap | 4 +- ...lig_false_inliner_9223372036854775807.snap | 4 +- ...lig_true_inliner_-9223372036854775808.snap | 4 +- ...__tests__force_brillig_true_inliner_0.snap | 4 +- ...llig_true_inliner_9223372036854775807.snap | 4 +- ...lig_true_inliner_-9223372036854775808.snap | 4 +- ...__tests__force_brillig_true_inliner_0.snap | 4 +- ...llig_true_inliner_9223372036854775807.snap | 4 +- ...lig_true_inliner_-9223372036854775808.snap | 4 +- ...__tests__force_brillig_true_inliner_0.snap | 4 +- ...llig_true_inliner_9223372036854775807.snap | 4 +- ...lig_true_inliner_-9223372036854775808.snap | 4 +- ...__tests__force_brillig_true_inliner_0.snap | 4 +- ...llig_true_inliner_9223372036854775807.snap | 4 +- 27 files changed, 270 insertions(+), 282 deletions(-) diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 4573d95bc87..4e0735204b7 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -88,9 +88,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 392 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 318 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Direct(32838) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(8) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(7), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 180 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 189 }, Jump { location: 184 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 189 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Load { destination: Relative(7), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 198 }, Load { destination: Relative(7), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(7), location: 205 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, JumpIf { condition: Relative(5), location: 213 }, Jump { location: 210 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(7), source: Relative(1) }, Jump { location: 225 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 225 }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 232 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 239 }, Call { location: 478 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(7), location: 255 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(5), location: 263 }, Jump { location: 260 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 278 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(7) }, JumpIf { condition: Relative(5), location: 276 }, Jump { location: 273 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 278 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 278 }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 284 }, Jump { location: 286 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 286 }, Load { destination: Relative(4), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 291 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 296 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 305 }, Jump { location: 299 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 304 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 312 }, Jump { location: 315 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Store { destination_pointer: Relative(1), source: Relative(4) }, Jump { location: 315 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 296 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 321 }, Jump { location: 327 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 323 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 330 }, Jump { location: 326 }, Jump { location: 327 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 334 }, Call { location: 481 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 339 }, Call { location: 484 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 342 }, Call { location: 487 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 349 }, Call { location: 487 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 456 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 359 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 379 }, Jump { location: 362 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 366 }, Jump { location: 376 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 376 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 323 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 388 }, Call { location: 481 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 359 }, 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: 397 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 392 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 404 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 409 }, Jump { location: 407 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 411 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 417 }, Jump { location: 414 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 404 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 424 }, Call { location: 487 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 430 }, Jump { location: 453 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 453 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 411 }, 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: 460 }, Jump { location: 462 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 477 }, 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: 474 }, 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: 467 }, 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: 477 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 393 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 319 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Direct(32838) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(8) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(7), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 180 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 190 }, Jump { location: 184 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(7), rhs: Relative(1) }, JumpIf { condition: Relative(8), location: 189 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(7), location: 206 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, JumpIf { condition: Relative(5), location: 214 }, Jump { location: 211 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(7), source: Relative(1) }, Jump { location: 226 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 226 }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 233 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 240 }, Call { location: 479 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(7), location: 256 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(5), location: 264 }, Jump { location: 261 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(7) }, JumpIf { condition: Relative(5), location: 277 }, Jump { location: 274 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 279 }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 285 }, Jump { location: 287 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 287 }, Load { destination: Relative(4), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 292 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 306 }, Jump { location: 300 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 305 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 313 }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Store { destination_pointer: Relative(1), source: Relative(4) }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 322 }, Jump { location: 328 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 324 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 331 }, Jump { location: 327 }, Jump { location: 328 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 335 }, Call { location: 482 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 340 }, Call { location: 485 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 343 }, Call { location: 488 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 350 }, Call { location: 488 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 457 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 360 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 380 }, Jump { location: 363 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 367 }, Jump { location: 377 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 377 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 324 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 389 }, Call { location: 482 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 360 }, 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: 398 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 393 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 405 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 410 }, Jump { location: 408 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 412 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 418 }, Jump { location: 415 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 405 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 425 }, Call { location: 488 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 431 }, Jump { location: 454 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 454 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 412 }, 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: 461 }, Jump { location: 463 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 478 }, 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: 475 }, 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: 468 }, 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: 478 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZnLTiNJEEX/xWsW+Yp89K8ghAyYliXLIDeMNEL8+8StjFsFC0at8Mb3uOy4lRkZ+XD5Y/d0eHj/fX88P7/82f26/dg9XI6n0/H3/enlcf92fDnr1Y9dwEuMKvFGNZom02xaTMW0mjbTbjqmJvNL5pfML5lfMr9kfsn8kvkl80vml/V7CarXM1SvF9USTPU+Ak2m2bSYiqnep0KbaTcdUyWYRtNkqn4NWkzFtJo20246ptZgGk2TqflV86vmV82vql+HdtMxtQXTaJpMs6n6DaiYIq8B0AidMAw6xgpJ7hgUZLcLoRIaoRMQjtQPhCO3IxISIRMKQQiVAEOkeMBQ+55CIMCwAxIhEwoBhgNQCc0ANZ0CIBI0PCVAIQihEhqhE4YBinoCDDMgETJB7F6o6FQAjQBDAQyDHAiRkAiZUAhCqIRGoHOmc6EzJkaqgETIhEIQQiU0QifAGYOCGTIBzhgCzJEJmVAIcMZYYJ5MaAaYGRmJwtSYoOE5AgpBCJXQCJ0wDDA1JsAHw4TJMAHhGB0Uf8ZYoPgz8oPin4BmoKeYBRkdRPFPwE3RHRT/hGGA4p+AcPQLxT9Bm1HQL5R6QcNQ4UXbk1HhJQMiIREyQWZURmGXAmiEToChNj5juV6cUeEThIAva78ySrQ0QFvW0IzqKx0QCYmQCYUAvwGohEbohGGwrMoLRALW5QDIhEIQQiU0QieosyAZqL4JkZAImVAIQqgE+CArWIcFSUDRCXKJEpvQCHOvyUuFqS4FBo2myTSbFtNqypuhxiag0RivngiZUKxBWHsnVEIjdMIwQEWJDm5BRU2IBBg2AMJ1CAuWQRmAwiuNV7ANBsAwwFo3IRISIRPUp0aAECoB+6t2uaDIJsAnAxIhE+BTAEKoBPgIoBOGAYpsQiQkQiawp0uRLVAJTMtSZAsMg6XIFogEDFP//LzZ8ex0/3Y5HHB0+nKY0iPW6/5yOL/tfp3fT6eb3T/70/vypT+v+/Oib/uLfqrJO5yfVNXw+Xg6gD5vtujwc6gOpwWXKGu4/H08+jPja3DEt8zGt1wc8T0wvod+XXzMnvjE/PXsyd/A9rHED188jiYW3zzxwv4PKVfGD098W+NbdcTHgN1tMYhBfqyAmH62SC2Zg+7nriasYxBDCj6HtDpEVxoiFunpoId8l0Pvq8NIVzt4ilF/3nE2Kbp6kdf5qOhySLK1of3YixT/rxHYs6wRX6o6jr9vxNgcgquksqwlpc1xOZR2rUPb2tCGy2FsDqNe6aCHGY9DyWtZ62nB41AjF3lFcbUBxw9rQ3W1QbYlRlw7nT6rWPMgxZeHvLahZtfkrLJlUq52qK481Lbmofqquo7VoQXPrqvPZda52YorD022Nvjy0Pq6RrXu2jB6WseiZ9fs7tu86M01u9tYN87uW2m/OXhmtwSmQaKnGqRwIKR4xkEqOyCuHEpjMUqvrnhZ45ur/Wv/m6f/dT11VNehoxbmz7cm1cH7t+Dpf5V41f2vPQDLOny+ObwuZcNTfW2sPwA9vz/6dnR3ndzX9SeM627vOx/V7XDj2w3Xrcx3qti2wu/pu9N3+8fj5dufQ59wuhz3D6eDvX1+Pz9++fTt31d+wj+XXi8vj4en98sBTts/TPpyW/Q3T2ntTh9c6bsRbmII+gbP6W9x7MsDn+Ex1W3p5ab0eveJlv0H", + "debug_symbols": "pZnNTmM5EIXfJess/Fcuu18FtVoBQitSFFAaRhoh3n18ruvcCwtGrcqG8yWhzi2Xyz+E993j8f7t96/T5en5z+7H3fvu/no6n0+/f52fHw6vp+fLePd9F/AjxiFxPzSaJtNsWkzFtJqqaTPtU5P5JfNL5pfML5lfMr9kfsn8kvkl88vj9xJ0vJ+h4/0ytATT8RyBJtNsWkzFdDynQtW0mfapEkyjaTIdfgotpmJaTdW0mfapNZhG02RqftX8qvlV86vDr0GbaZ+qwTSaJtNsOvw6VExR1wBQQiN0g4a5QpEbJgXVbUKoBCU0g44olL5jilHbngiZUAhCqAQlII1R4hRgqIBIgGEDZEIhCAGGHaCEZoBeTgGQCCM8JYAQKkEJjdAN0MsTIgGGGZAJhVDtWejkVACNAMMx5JQDIRISIRMKQQiVoIRGoHOhc6EzFkRCebEiJhSCECpBCY3QDbAwEiYFK2MCnDEFWBsTCkEIcMZcYH1MaAZYERmFwpKYMMJzBAihEpTQCN0AK2JCJMAH04RFMAHhmB30fMZcoOcz6tMiAWlgpGj+jAGi5yfgoRhO6wZo/gmRgHCMC80/YaRRMC60ehmJZXR4SYARVTIgETKhECqjEF4AjdANsGsXAWRzRodPqAT88hhXRosWBcw9NKP7SgMkQiYUghDg1wFKaIRusGzGC0RCImA/DoBCEEIlKKERugG6T1AMdN+ERMiEQhBCJagBtmNBVbD/CoqAphPUEi02oRH6rNPSYdBomkyzaTEVU53a+DD02AQkjflqmVAIYglhy52ghEboBmg/QEFHSQVEQiLAUAEIH1NYsA1KBwjfaXwHx98odMFeNyESEiETCmH41AioBCXgXB1DLmiyCfBBzmiyCYUAnwKoBCXARwDdAE02IRISIRMKgSNdmmwBJbAsS5MBliZbIBISAdPUPj72O96dfr1ej0dcnT5dpsYV6+VwPV5edz8ub+fzfvfP4fy2/NKfl8Nl0dfDdXw6ine8PA4dhk+n8xH0sd+iw/ehJagFj2lcw+Xv4zGeGV+DI14zk9dcHPEtML6Fdlt8zJ74xPq17Klfx/GxxHdfPK4mFq+eeOH4u5Qb47snXtd4rY74GHC6LQYxyLcdENP3FkmTOSRtrhTWOYghBZ9DWh2iqwwRm/R0GJd8l0Nrq0NPNzt4mnH8ecfVNNA1iryux4EuhyRbDvrtKFL8vyRwZlkSn7o69r9Pom8OwdVSWdaWGum4HIre6qBbDtpdDn1z6PVGh3Gr8TiUvLb1uDZ4HGrkJj9QXDng+mE5VFcOsm0x4jrpxncVax2k+OqQ1xxqdi3OKlsl5WaH6qpD1bUO1dfVta8OGjyn7vheZl2bWlx1UNly8NVB27pHaXMdGC2tc9Gya3W3bV00da1u7evB2Xw77RcHz+qWwDJI9HSDFE6EFM88SOUAxFVDUTajtOqKlzVeXfmv41fP+Ot666iuS0ctrJ9vT6qdz9fgGX+VeNPzb70Ayzp9vjW8bmXd033a1z8APX9/tO3q7rq5r/tP6Lc93nc/qtvlxncarkeZ71axHYVfy/dzvDo8nK5f/jn0Aafr6XB/PtrLp7fLw6dPX/994Sf859LL9fnh+Ph2PcJp+w/T+HFXxk29aPs5vsEar3rYxxDGC3yLeZd73ueOz/C1/V1psi9Nf34gs/8A", "file_map": { "19": { "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap index 4573d95bc87..4e0735204b7 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_0.snap @@ -88,9 +88,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 392 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 318 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Direct(32838) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(8) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(7), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 180 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 189 }, Jump { location: 184 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 189 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Load { destination: Relative(7), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 198 }, Load { destination: Relative(7), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(7), location: 205 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, JumpIf { condition: Relative(5), location: 213 }, Jump { location: 210 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(7), source: Relative(1) }, Jump { location: 225 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 225 }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 232 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 239 }, Call { location: 478 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 398 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(7), location: 255 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(5), location: 263 }, Jump { location: 260 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 278 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(7) }, JumpIf { condition: Relative(5), location: 276 }, Jump { location: 273 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 278 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 278 }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 284 }, Jump { location: 286 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 286 }, Load { destination: Relative(4), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 291 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 296 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 305 }, Jump { location: 299 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 304 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 312 }, Jump { location: 315 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Store { destination_pointer: Relative(1), source: Relative(4) }, Jump { location: 315 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 296 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 321 }, Jump { location: 327 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 323 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 330 }, Jump { location: 326 }, Jump { location: 327 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 334 }, Call { location: 481 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 339 }, Call { location: 484 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 342 }, Call { location: 487 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 349 }, Call { location: 487 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 456 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 359 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 379 }, Jump { location: 362 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 366 }, Jump { location: 376 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 376 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 323 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 388 }, Call { location: 481 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 359 }, 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: 397 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 392 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 404 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 409 }, Jump { location: 407 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 411 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 417 }, Jump { location: 414 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 404 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 424 }, Call { location: 487 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 430 }, Jump { location: 453 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 456 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 453 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 411 }, 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: 460 }, Jump { location: 462 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 477 }, 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: 474 }, 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: 467 }, 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: 477 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32839), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U32) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U32) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Cast { destination: Direct(32879), source: Direct(32879), bit_size: Integer(U8) }, Cast { destination: Direct(32880), source: Direct(32880), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32839) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32840 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32844 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32849 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 106 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32881 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 4 }, Return, Call { location: 393 }, 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(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Mov { destination: Relative(9), source: Relative(7) }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 124 }, Store { destination_pointer: Relative(9), source: Direct(32835) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Jump { location: 118 }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(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(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Direct(32835) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 319 }, Jump { location: 138 }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, Load { destination: Relative(7), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Direct(32835) }, JumpIf { condition: Relative(5), location: 145 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(7), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 153 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Direct(32837) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Direct(32838) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(5) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(8) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(7), source: Relative(11) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 180 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 190 }, Jump { location: 184 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U8, lhs: Relative(7), rhs: Relative(1) }, JumpIf { condition: Relative(8), location: 189 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32837) }, Store { destination_pointer: Relative(10), source: Relative(9) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 199 }, Load { destination: Relative(7), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, JumpIf { condition: Relative(7), location: 206 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, JumpIf { condition: Relative(5), location: 214 }, Jump { location: 211 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(7), source: Relative(1) }, Jump { location: 226 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(10) }, output: HeapArray { pointer: Relative(11), size: 32 } }), BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 226 }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(32837) }, Load { destination: Relative(3), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 233 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 240 }, Call { location: 479 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 10 }, Mov { destination: Relative(10), source: Direct(0) }, Mov { destination: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 399 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, JumpIf { condition: Relative(7), location: 256 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, JumpIf { condition: Relative(5), location: 264 }, Jump { location: 261 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32837) }, Store { destination_pointer: Relative(8), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(7) }, JumpIf { condition: Relative(5), location: 277 }, Jump { location: 274 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(1), source: Relative(3) }, Jump { location: 279 }, Store { destination_pointer: Relative(1), source: Relative(2) }, Jump { location: 279 }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32835) }, JumpIf { condition: Relative(3), location: 285 }, Jump { location: 287 }, Store { destination_pointer: Relative(1), source: Relative(9) }, Jump { location: 287 }, Load { destination: Relative(4), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 292 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Direct(32835) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, JumpIf { condition: Relative(4), location: 306 }, Jump { location: 300 }, Load { destination: Relative(2), source_pointer: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 305 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Direct(32835) }, JumpIf { condition: Relative(4), location: 313 }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Store { destination_pointer: Relative(1), source: Relative(4) }, Jump { location: 316 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32837) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 297 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 322 }, Jump { location: 328 }, Mov { destination: Relative(11), source: Direct(32835) }, Jump { location: 324 }, BinaryIntOp { destination: Relative(12), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Direct(32838) }, JumpIf { condition: Relative(12), location: 331 }, Jump { location: 327 }, Jump { location: 328 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(32837) }, Mov { destination: Relative(5), source: Relative(11) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(14), location: 335 }, Call { location: 482 }, Load { destination: Relative(14), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(15), op: Sub, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(11), rhs: Relative(9) }, JumpIf { condition: Relative(16), location: 340 }, Call { location: 485 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Direct(32838) }, JumpIf { condition: Relative(16), location: 343 }, Call { location: 488 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(15) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(15), location: 350 }, Call { location: 488 }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 457 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Store { destination_pointer: Relative(18), source: Relative(16) }, Store { destination_pointer: Relative(7), source: Relative(15) }, Mov { destination: Relative(12), source: Direct(32835) }, Jump { location: 360 }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Direct(32838) }, JumpIf { condition: Relative(13), location: 380 }, Jump { location: 363 }, Load { destination: Relative(12), source_pointer: Relative(2) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(10) }, JumpIf { condition: Relative(13), location: 367 }, Jump { location: 377 }, Load { destination: Relative(12), source_pointer: Relative(2) }, Load { destination: Relative(13), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(32838) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Store { destination_pointer: Relative(6), source: Relative(14) }, Jump { location: 377 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32837) }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 324 }, Load { destination: Relative(13), source_pointer: Relative(2) }, Load { destination: Relative(14), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(15) }, BinaryIntOp { destination: Relative(16), op: LessThanEquals, bit_size: U32, lhs: Relative(13), rhs: Relative(14) }, JumpIf { condition: Relative(16), location: 389 }, Call { location: 482 }, Store { destination_pointer: Relative(2), source: Relative(14) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(32837) }, Mov { destination: Relative(12), source: Relative(13) }, Jump { location: 360 }, 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: 398 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 393 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, Mov { destination: Relative(2), source: Direct(32837) }, Jump { location: 405 }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(1), location: 410 }, Jump { location: 408 }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Mov { destination: Relative(1), source: Direct(32835) }, Jump { location: 412 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 418 }, Jump { location: 415 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 405 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 425 }, Call { location: 488 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, JumpIf { condition: Relative(4), location: 431 }, Jump { location: 454 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Load { destination: Relative(6), source_pointer: Relative(8) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Store { destination_pointer: Relative(9), source: Relative(6) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 457 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Store { destination_pointer: Relative(8), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 454 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32837) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 412 }, 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: 461 }, Jump { location: 463 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 478 }, 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: 475 }, 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: 468 }, 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: 478 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZnLTiNJEEX/xWsW+Yp89K8ghAyYliXLIDeMNEL8+8StjFsFC0at8Mb3uOy4lRkZ+XD5Y/d0eHj/fX88P7/82f26/dg9XI6n0/H3/enlcf92fDnr1Y9dwEuMKvFGNZom02xaTMW0mjbTbjqmJvNL5pfML5lfMr9kfsn8kvkl80vml/V7CarXM1SvF9USTPU+Ak2m2bSYiqnep0KbaTcdUyWYRtNkqn4NWkzFtJo20246ptZgGk2TqflV86vmV82vql+HdtMxtQXTaJpMs6n6DaiYIq8B0AidMAw6xgpJ7hgUZLcLoRIaoRMQjtQPhCO3IxISIRMKQQiVAEOkeMBQ+55CIMCwAxIhEwoBhgNQCc0ANZ0CIBI0PCVAIQihEhqhE4YBinoCDDMgETJB7F6o6FQAjQBDAQyDHAiRkAiZUAhCqIRGoHOmc6EzJkaqgETIhEIQQiU0QifAGYOCGTIBzhgCzJEJmVAIcMZYYJ5MaAaYGRmJwtSYoOE5AgpBCJXQCJ0wDDA1JsAHw4TJMAHhGB0Uf8ZYoPgz8oPin4BmoKeYBRkdRPFPwE3RHRT/hGGA4p+AcPQLxT9Bm1HQL5R6QcNQ4UXbk1HhJQMiIREyQWZURmGXAmiEToChNj5juV6cUeEThIAva78ySrQ0QFvW0IzqKx0QCYmQCYUAvwGohEbohGGwrMoLRALW5QDIhEIQQiU0QieosyAZqL4JkZAImVAIQqgE+CArWIcFSUDRCXKJEpvQCHOvyUuFqS4FBo2myTSbFtNqypuhxiag0RivngiZUKxBWHsnVEIjdMIwQEWJDm5BRU2IBBg2AMJ1CAuWQRmAwiuNV7ANBsAwwFo3IRISIRPUp0aAECoB+6t2uaDIJsAnAxIhE+BTAEKoBPgIoBOGAYpsQiQkQiawp0uRLVAJTMtSZAsMg6XIFogEDFP//LzZ8ex0/3Y5HHB0+nKY0iPW6/5yOL/tfp3fT6eb3T/70/vypT+v+/Oib/uLfqrJO5yfVNXw+Xg6gD5vtujwc6gOpwWXKGu4/H08+jPja3DEt8zGt1wc8T0wvod+XXzMnvjE/PXsyd/A9rHED188jiYW3zzxwv4PKVfGD098W+NbdcTHgN1tMYhBfqyAmH62SC2Zg+7nriasYxBDCj6HtDpEVxoiFunpoId8l0Pvq8NIVzt4ilF/3nE2Kbp6kdf5qOhySLK1of3YixT/rxHYs6wRX6o6jr9vxNgcgquksqwlpc1xOZR2rUPb2tCGy2FsDqNe6aCHGY9DyWtZ62nB41AjF3lFcbUBxw9rQ3W1QbYlRlw7nT6rWPMgxZeHvLahZtfkrLJlUq52qK481Lbmofqquo7VoQXPrqvPZda52YorD022Nvjy0Pq6RrXu2jB6WseiZ9fs7tu86M01u9tYN87uW2m/OXhmtwSmQaKnGqRwIKR4xkEqOyCuHEpjMUqvrnhZ45ur/Wv/m6f/dT11VNehoxbmz7cm1cH7t+Dpf5V41f2vPQDLOny+ObwuZcNTfW2sPwA9vz/6dnR3ndzX9SeM627vOx/V7XDj2w3Xrcx3qti2wu/pu9N3+8fj5dufQ59wuhz3D6eDvX1+Pz9++fTt31d+wj+XXi8vj4en98sBTts/TPpyW/Q3T2ntTh9c6bsRbmII+gbP6W9x7MsDn+Ex1W3p5ab0eveJlv0H", + "debug_symbols": "pZnNTmM5EIXfJess/Fcuu18FtVoBQitSFFAaRhoh3n18ruvcCwtGrcqG8yWhzi2Xyz+E993j8f7t96/T5en5z+7H3fvu/no6n0+/f52fHw6vp+fLePd9F/AjxiFxPzSaJtNsWkzFtJqqaTPtU5P5JfNL5pfML5lfMr9kfsn8kvkl88vj9xJ0vJ+h4/0ytATT8RyBJtNsWkzFdDynQtW0mfapEkyjaTIdfgotpmJaTdW0mfapNZhG02RqftX8qvlV86vDr0GbaZ+qwTSaJtNsOvw6VExR1wBQQiN0g4a5QpEbJgXVbUKoBCU0g44olL5jilHbngiZUAhCqAQlII1R4hRgqIBIgGEDZEIhCAGGHaCEZoBeTgGQCCM8JYAQKkEJjdAN0MsTIgGGGZAJhVDtWejkVACNAMMx5JQDIRISIRMKQQiVoIRGoHOhc6EzFkRCebEiJhSCECpBCY3QDbAwEiYFK2MCnDEFWBsTCkEIcMZcYH1MaAZYERmFwpKYMMJzBAihEpTQCN0AK2JCJMAH04RFMAHhmB30fMZcoOcz6tMiAWlgpGj+jAGi5yfgoRhO6wZo/gmRgHCMC80/YaRRMC60ehmJZXR4SYARVTIgETKhECqjEF4AjdANsGsXAWRzRodPqAT88hhXRosWBcw9NKP7SgMkQiYUghDg1wFKaIRusGzGC0RCImA/DoBCEEIlKKERugG6T1AMdN+ERMiEQhBCJagBtmNBVbD/CoqAphPUEi02oRH6rNPSYdBomkyzaTEVU53a+DD02AQkjflqmVAIYglhy52ghEboBmg/QEFHSQVEQiLAUAEIH1NYsA1KBwjfaXwHx98odMFeNyESEiETCmH41AioBCXgXB1DLmiyCfBBzmiyCYUAnwKoBCXARwDdAE02IRISIRMKgSNdmmwBJbAsS5MBliZbIBISAdPUPj72O96dfr1ej0dcnT5dpsYV6+VwPV5edz8ub+fzfvfP4fy2/NKfl8Nl0dfDdXw6ine8PA4dhk+n8xH0sd+iw/ehJagFj2lcw+Xv4zGeGV+DI14zk9dcHPEtML6Fdlt8zJ74xPq17Klfx/GxxHdfPK4mFq+eeOH4u5Qb47snXtd4rY74GHC6LQYxyLcdENP3FkmTOSRtrhTWOYghBZ9DWh2iqwwRm/R0GJd8l0Nrq0NPNzt4mnH8ecfVNNA1iryux4EuhyRbDvrtKFL8vyRwZlkSn7o69r9Pom8OwdVSWdaWGum4HIre6qBbDtpdDn1z6PVGh3Gr8TiUvLb1uDZ4HGrkJj9QXDng+mE5VFcOsm0x4jrpxncVax2k+OqQ1xxqdi3OKlsl5WaH6qpD1bUO1dfVta8OGjyn7vheZl2bWlx1UNly8NVB27pHaXMdGC2tc9Gya3W3bV00da1u7evB2Xw77RcHz+qWwDJI9HSDFE6EFM88SOUAxFVDUTajtOqKlzVeXfmv41fP+Ot666iuS0ctrJ9vT6qdz9fgGX+VeNPzb70Ayzp9vjW8bmXd033a1z8APX9/tO3q7rq5r/tP6Lc93nc/qtvlxncarkeZ71axHYVfy/dzvDo8nK5f/jn0Aafr6XB/PtrLp7fLw6dPX/994Sf859LL9fnh+Ph2PcJp+w/T+HFXxk29aPs5vsEar3rYxxDGC3yLeZd73ueOz/C1/V1psi9Nf34gs/8A", "file_map": { "19": { "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 411bd34352c..3609e99d16d 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_1/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -88,9 +88,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 490 }, 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(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 121 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 115 }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(13), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Relative(2) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(15), location: 416 }, Jump { location: 138 }, Load { destination: Relative(14), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(9) }, Load { destination: Relative(8), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 145 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Load { destination: Relative(8), source_pointer: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(7) }, JumpIf { condition: Relative(8), location: 153 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, 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(14), source: Relative(9) }, Store { destination_pointer: Relative(14), source: Relative(10) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(7) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(8) }, Mov { destination: Relative(5), source: Relative(10) }, Jump { location: 172 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(8), location: 369 }, Jump { location: 175 }, Load { destination: Relative(5), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Load { destination: Relative(8), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 182 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 191 }, Jump { location: 186 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U8, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 191 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Load { destination: Relative(8), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(10) }, Store { destination_pointer: Relative(14), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Jump { location: 200 }, Load { destination: Relative(8), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, JumpIf { condition: Relative(8), location: 207 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, JumpIf { condition: Relative(5), location: 215 }, Jump { location: 212 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(8), source: Relative(1) }, Jump { location: 227 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(9), size: Relative(14) }, output: HeapArray { pointer: Relative(15), size: 32 } }), BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Store { destination_pointer: Relative(8), source: Relative(3) }, Jump { location: 227 }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Load { destination: Relative(8), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(3), rhs: Relative(8) }, JumpIf { condition: Relative(4), location: 234 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(3), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 241 }, Call { location: 518 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, 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: Relative(3) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 248 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 322 }, Jump { location: 251 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 259 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, JumpIf { condition: Relative(5), location: 267 }, Jump { location: 264 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 282 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Store { destination_pointer: Relative(9), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, JumpIf { condition: Relative(5), location: 280 }, Jump { location: 277 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 282 }, Store { destination_pointer: Relative(3), source: Relative(7) }, Jump { location: 282 }, Load { destination: Relative(1), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 288 }, Jump { location: 290 }, Store { destination_pointer: Relative(3), source: Relative(11) }, Jump { location: 290 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, JumpIf { condition: Relative(3), location: 295 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 300 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 309 }, Jump { location: 303 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 308 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, 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(5), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 316 }, Jump { location: 319 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(7) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 319 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 300 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 324 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(8), location: 330 }, Jump { location: 327 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 248 }, Load { destination: Relative(8), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 337 }, Call { location: 521 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Load { destination: Relative(14), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(14) }, JumpIf { condition: Relative(8), location: 343 }, Jump { location: 366 }, Load { destination: Relative(8), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Store { destination_pointer: Relative(17), source: Relative(14) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Store { destination_pointer: Relative(16), source: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(8) }, Jump { location: 366 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Mov { destination: Relative(3), source: Relative(8) }, Jump { location: 324 }, Mov { destination: Relative(8), source: Relative(2) }, Jump { location: 371 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, JumpIf { condition: Relative(14), location: 377 }, Jump { location: 374 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(8) }, Jump { location: 172 }, Load { destination: Relative(14), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 384 }, Call { location: 521 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(8) }, Load { destination: Relative(16), source_pointer: Relative(18) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(16) }, JumpIf { condition: Relative(14), location: 390 }, Jump { location: 413 }, Load { destination: Relative(14), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(8) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Store { destination_pointer: Relative(18), source: Relative(15) }, Store { destination_pointer: Relative(9), source: Relative(14) }, Jump { location: 413 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 371 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 419 }, Jump { location: 425 }, Mov { destination: Relative(15), source: Relative(2) }, Jump { location: 421 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 428 }, Jump { location: 424 }, Jump { location: 425 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(15) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 432 }, Call { location: 524 }, Load { destination: Relative(18), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 437 }, Call { location: 527 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(19), rhs: Relative(12) }, JumpIf { condition: Relative(20), location: 440 }, Call { location: 521 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(19) }, Load { destination: Relative(20), source_pointer: Relative(22) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(9) }, JumpIf { condition: Relative(19), location: 447 }, Call { location: 521 }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 496 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(20) }, Store { destination_pointer: Relative(8), source: Relative(19) }, Mov { destination: Relative(16), source: Relative(2) }, Jump { location: 457 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, JumpIf { condition: Relative(17), location: 477 }, Jump { location: 460 }, Load { destination: Relative(16), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, JumpIf { condition: Relative(17), location: 464 }, Jump { location: 474 }, Load { destination: Relative(16), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 496 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Store { destination_pointer: Relative(6), source: Relative(18) }, Jump { location: 474 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Mov { destination: Relative(15), source: Relative(16) }, Jump { location: 421 }, Load { destination: Relative(17), source_pointer: Relative(7) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(16) }, Load { destination: Relative(19), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(17), rhs: Relative(18) }, JumpIf { condition: Relative(20), location: 486 }, Call { location: 524 }, Store { destination_pointer: Relative(7), source: Relative(18) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Mov { destination: Relative(16), source: Relative(17) }, Jump { location: 457 }, 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: 495 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, 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: 500 }, Jump { location: 502 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 517 }, 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: 514 }, 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: 507 }, 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: 517 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 491 }, 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(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Mov { destination: Relative(7), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(7), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, Mov { destination: Relative(10), source: Relative(8) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(9) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 121 }, Store { destination_pointer: Relative(10), source: Relative(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Jump { location: 115 }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 4 }, Const { destination: Relative(13), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 4864 }, Mov { destination: Relative(5), source: Relative(2) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(15), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, JumpIf { condition: Relative(15), location: 417 }, Jump { location: 138 }, Load { destination: Relative(14), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(9) }, Load { destination: Relative(8), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 145 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Load { destination: Relative(8), source_pointer: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(7) }, JumpIf { condition: Relative(8), location: 153 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, 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(14), source: Relative(9) }, Store { destination_pointer: Relative(14), source: Relative(10) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(7) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(11) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(14), source: Relative(12) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(8) }, Mov { destination: Relative(5), source: Relative(10) }, Jump { location: 172 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(8), location: 370 }, Jump { location: 175 }, Load { destination: Relative(5), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Load { destination: Relative(8), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 182 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(1), bit_size: Integer(U8), value: 0 }, JumpIf { condition: Relative(5), location: 192 }, Jump { location: 186 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 1 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(9), location: 191 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Jump { location: 201 }, Load { destination: Relative(8), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(9), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(10) }, Store { destination_pointer: Relative(14), source: Relative(11) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Jump { location: 201 }, Load { destination: Relative(8), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(14) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(11) }, JumpIf { condition: Relative(8), location: 208 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Mov { destination: Relative(8), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, JumpIf { condition: Relative(5), location: 216 }, Jump { location: 213 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 5 }, Store { destination_pointer: Relative(8), source: Relative(1) }, Jump { location: 228 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(9) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(9), size: Relative(14) }, output: HeapArray { pointer: Relative(15), size: 32 } }), BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Store { destination_pointer: Relative(8), source: Relative(3) }, Jump { location: 228 }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Load { destination: Relative(8), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(3), rhs: Relative(8) }, JumpIf { condition: Relative(4), location: 235 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(3), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 242 }, Call { location: 519 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(4) }, 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: Relative(3) }, Mov { destination: Relative(1), source: Relative(10) }, Jump { location: 249 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 323 }, Jump { location: 252 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 260 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, JumpIf { condition: Relative(5), location: 268 }, Jump { location: 265 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 283 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 12 }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Store { destination_pointer: Relative(9), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, JumpIf { condition: Relative(5), location: 281 }, Jump { location: 278 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 6 }, Store { destination_pointer: Relative(3), source: Relative(1) }, Jump { location: 283 }, Store { destination_pointer: Relative(3), source: Relative(7) }, Jump { location: 283 }, Load { destination: Relative(1), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Load { destination: Relative(4), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 289 }, Jump { location: 291 }, Store { destination_pointer: Relative(3), source: Relative(11) }, Jump { location: 291 }, Load { destination: Relative(4), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, JumpIf { condition: Relative(3), location: 296 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(1), source: Relative(2) }, Jump { location: 301 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 310 }, Jump { location: 304 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 309 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(4), source_pointer: Relative(6) }, 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(5), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 317 }, Jump { location: 320 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(7) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 320 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 301 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 325 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(8), location: 331 }, Jump { location: 328 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 249 }, Load { destination: Relative(8), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(12) }, JumpIf { condition: Relative(14), location: 338 }, Call { location: 522 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Load { destination: Relative(14), source_pointer: Relative(16) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(9), rhs: Relative(14) }, JumpIf { condition: Relative(8), location: 344 }, Jump { location: 367 }, Load { destination: Relative(8), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Load { destination: Relative(9), source_pointer: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(15), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Store { destination_pointer: Relative(17), source: Relative(14) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(8), source: Direct(32773) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Relative(1) }, Store { destination_pointer: Relative(16), source: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(8) }, Jump { location: 367 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(10) }, Mov { destination: Relative(3), source: Relative(8) }, Jump { location: 325 }, Mov { destination: Relative(8), source: Relative(2) }, Jump { location: 372 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, JumpIf { condition: Relative(14), location: 378 }, Jump { location: 375 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(8) }, Jump { location: 172 }, Load { destination: Relative(14), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 385 }, Call { location: 522 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(8) }, Load { destination: Relative(16), source_pointer: Relative(18) }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(16) }, JumpIf { condition: Relative(14), location: 391 }, Jump { location: 414 }, Load { destination: Relative(14), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Load { destination: Relative(15), source_pointer: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(16), source_pointer: Relative(18) }, Mov { destination: Direct(32771), source: Relative(14) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(17), source: Direct(32773) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(8) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(14), source: Direct(32773) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Store { destination_pointer: Relative(18), source: Relative(15) }, Store { destination_pointer: Relative(9), source: Relative(14) }, Jump { location: 414 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(10) }, Mov { destination: Relative(8), source: Relative(14) }, Jump { location: 372 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 420 }, Jump { location: 426 }, Mov { destination: Relative(15), source: Relative(2) }, Jump { location: 422 }, BinaryIntOp { destination: Relative(16), op: LessThan, bit_size: U32, lhs: Relative(15), rhs: Relative(12) }, JumpIf { condition: Relative(16), location: 429 }, Jump { location: 425 }, Jump { location: 426 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(10) }, Mov { destination: Relative(5), source: Relative(15) }, Jump { location: 135 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(17) }, JumpIf { condition: Relative(18), location: 433 }, Call { location: 525 }, Load { destination: Relative(18), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(19), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Relative(15) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 438 }, Call { location: 528 }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(19), rhs: Relative(12) }, JumpIf { condition: Relative(20), location: 441 }, Call { location: 522 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(19) }, Load { destination: Relative(20), source_pointer: Relative(22) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(19), op: LessThan, bit_size: U32, lhs: Relative(17), rhs: Relative(9) }, JumpIf { condition: Relative(19), location: 448 }, Call { location: 522 }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 33 }, Call { location: 497 }, Mov { destination: Relative(19), source: Direct(32773) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(19), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(17) }, Store { destination_pointer: Relative(22), source: Relative(20) }, Store { destination_pointer: Relative(8), source: Relative(19) }, Mov { destination: Relative(16), source: Relative(2) }, Jump { location: 458 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(16), rhs: Relative(12) }, JumpIf { condition: Relative(17), location: 478 }, Jump { location: 461 }, Load { destination: Relative(16), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, JumpIf { condition: Relative(17), location: 465 }, Jump { location: 475 }, Load { destination: Relative(16), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(6) }, Mov { destination: Direct(32771), source: Relative(17) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 5 }, Call { location: 497 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, Store { destination_pointer: Relative(19), source: Relative(16) }, Store { destination_pointer: Relative(6), source: Relative(18) }, Jump { location: 475 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(10) }, Mov { destination: Relative(15), source: Relative(16) }, Jump { location: 422 }, Load { destination: Relative(17), source_pointer: Relative(7) }, Load { destination: Relative(18), source_pointer: Relative(8) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(16) }, Load { destination: Relative(19), source_pointer: Relative(21) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(20), op: LessThanEquals, bit_size: U32, lhs: Relative(17), rhs: Relative(18) }, JumpIf { condition: Relative(20), location: 487 }, Call { location: 525 }, Store { destination_pointer: Relative(7), source: Relative(18) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Mov { destination: Relative(16), source: Relative(17) }, Jump { location: 458 }, 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: 496 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, 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: 501 }, Jump { location: 503 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 518 }, 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: 515 }, 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: 508 }, 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: 518 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZnNbhs5EITfRWcf+NPdJPMqgREojrIQIMiGYi+wCPzuyxp2zSQHGQbn4v4kuWvIZk2TI/0+/Dh9f/vn2/n68/nX4cvX34fvt/Plcv7n2+X56fh6fr72d38fAv7EYIcv8aHH4rF6bCPG4DF6TB6zR/GoHl0vul50veh6yfWS6yXXS66XXC+5XnK93F8nxK6XEbue9CjBY9dTxOQxexSP6rHrGWLxWD22ETV4jB6Tx65XEMWjejSPxWP12Ea04DF6TB5dz1zPXM9cz7peQ6we24gF9QoAFAiVKagQSlMKATVHkUpzqIEQCdBB4SrSMcNaCJXQHFogIB3Da0ivgEwQghKMUAh1QAoQbIAumAIgEbpgigAhKMEIXTAlQCU0B/gzZUAmIF0BRiiESmgOsOeASEgECBpACEoofq0EwQJoDhmCmHKOhETIBCEowQiFUAnNQagsVBYqw/wZxYT7BygB9w9qCINnVAwOT1gLWDxjFvD4AGQJwAiFUAl9PBn1gdMHRAJ0UB+YewDSURbYekBzKIEQCYmQCUKADmYKqy8Ah2fMAsYWzLT2LMFMqxD6MARThsMFE4SxB/SLCqYDYw/IBCEgHfOCsQf0YUifV4afpQCQVQHIagAlGKEQmmehyWoAREIioI9FgLky3DugOcCQmgBlrGmG65Z34DrNgETIBCEowQhdRwVQCc0BrlMFZAJ0UISlxS5gBOhggnDdgOaAPqsYPHw4IBEyQQhKMAJnuvhwgeaw+HCBSEiETBCCOcB1ikWBx9BXMzw23sEWgbVAO10AZhsQCYmQCV3HoAPXDTAC9h5cFPYbAB1UHvYbkAnQQeVhvwFGgA6WAH11QBsgMOSASEiETPCZSlCCEQqhEprDciBYIBIyAQPr6y5onlYAuuzWgr5oFdAc4NABkZAIGGADCEEJRiiESmgOcGgJgEhIhEwQghKMgI0cs4FnBzQHeHZAJCRCJggBOn1tZTkBoAjLEUAAQlCCjTot/RGxemwjLs0RMXpMHsUjLwavDsCgscrw6oBISD4geHWAEJRgBCjn9/eHAw+P315vpxPOjn+cJvsZ8+V4O11fD1+ub5fLw+Hf4+Vt+adfL8frEl+Pt/5pr/Dp+qPHLvjzfDmB3h+27HA/tZvSkyXqmq6fz0fjGPkWJvJL5uBLlon8GphfQ92XH/NMfmL9ap6pX8N2v+S3uXwc+Dy/3Muv9/MTfL3k911/Ih+b1ZKuNpHdj8ee3g/BM7NXrl5T2ZnfZvLLml9sIj8GnJNGAYLerX/UnQv44RBWB8WQwpxCWhXiVBkiDjZDoT+bTSnUuiq0tFuhzCikuLq5PwTNKOS1m3ScUki6jaHcnUWSjwaB45QP4g9Xx/b5QbRNIUxZKutqqT6cKQUpexXKNoZytzvgIW/XvfmRwCe660fpe9tr/z5oK0GznQr91DyjIHm9L/txdEbBIvfYjjo1BtN1DDY1Bt16pE4dNPp3ZGsdVObqkNcxWJ7qLqZbJXW3gk3VwcpaBytzdWirQgkzx4ZYtuZSZKoORbcxzNWh1LXJljq149W0rkXNU3d33e6LWqbu7tLWnb/ObRV/KehMmyxtfYSYSd/cFNJUlw5rEUPbOYCp/Jht69FTApsNbG4E291gaeI54hMrWPctYN25fnXf8tWdq1d3Ll7duXYf3MAa2IU0zjRjFfZBlanrG+unUy1MC/cCrTaVvx7yapka/zr/MjN/W59abOqhxYT1mzsSWOP1S5iZv2m8c/3H/ur4dL799QvtO5Ru5+P3y8lf/ny7Pv3x6et/L/yEv/C+3J6fTj/ebicobT/z9j9fpe8+Gstj/5q4v2rhIYbwiF96l8/CgzTFy/4t4VftD3ea2uM7RvY/", + "debug_symbols": "pZnNbhs5EITfRWcf+NPNJvMqgREojrIQIMiGYi+wCPzuyxp2zSQHGQbn4v4kuWvIZk2TI/0+/Dh9f/vn2/n68/nX4cvX34fvt/Plcv7n2+X56fh6fr72d38fAv7EUA5f4kOP5rF6bCPG4DF6TB6zR/GoHl0vul50veh6yfWS6yXXS66XXC+5XnK93F8nxK6XEbue9CjBY9dTxOQxexSP6rHrFUTzWD22ETV4jB6Tx65niOJRPRaP5rF6bCOW4DF6TB5dr7hecb3ieqXrNcTqsY1oqFcAoECojKFCKI0ZATVHkaw51ECIBOigcBXpmGE1QiU0hxYIyMLwGparAoSghEIwQiW0ASlgGA3QBVMAZEIXTBGghEIwQhdMCdAcYNMB0MkAISBdAUaohOYAVw6IhETIBAgWgBIKofq1EgR7fVIOBAhiyjkRMkEISigEI1RCc4DhB1BZqCxUhukzignXDyiErpNRQxg7o2JwdsJawNoZs4C3ByBLAEaohOYAg2fUBw4fkAjQQX1g6gFIR1lg5wUsECIhETJBCEqADmYKhy8AY2fMovYswUxrzxLMtCqhD0MwZRhbMMEWCf2igunA2AOEoASkY14w9oA+DOnzyvCzGABZFYCsBigEI1QHmHbJQnPVAEiETED/igBzZbh3AZh2AHpbAtSxphmuW96B6zQDMkEISigEI3QdFUBzgOsGQFkBQoAOigCPDTACdDBBuG4BtNcB0MHg4cMBmSAEJRSCETjTxYeAxYcLREIiZIIQlGAOcJ1iUdhXMzw23sHWgLVAFx0QCYmQCULoOgU6cN0AI2DPwUVhvwHQQeVhvwFCgA4qD/sNMAJ0sAToqwAJgRAJiZAJQvCZynIGWMAIldAclnPAApGQCELAwPq6C5pnMUBZdmtBXyx93QR9cUAkJEImYIANoIRCMEIlNAc4dAB22gBIhEwQghIKwQjYwDEbeHYBeHZAJCRCJghBCdDpayvLzo8iLFu/AJRQCDbqVKrHNuLSHRGjx+Qxe1SPvBi8ugC8alhleHVAImQfELw6QAmFYAQo5/f3hwMPj99eb6cTzo5/nCb7GfPleDtdXw9frm+Xy8Ph3+PlbfmnXy/H6xJfj7f+aa/w6fqjxy7483w5gd4ftuxwP7W705Ml6pqun89H4xj5JUzkW+bgLctEfg3Mr6Huy495Jj+xfjXP1K9hu1/y21w+Dnyeb/fy6/38BF8v+X37n8jHZrWka5nI7sdjT48tzsxeuXpNZWd+m8m3Nd/KRH4MOCeNAgS9W/+oOxfwwyGsDoohhTmFtCrEqTJEHGyGQn82m1KodVVoabeCzSikuLq5Pw3NKOS1m3ScUki6jcHuziLJR4PAccoH8YerY/v8INqmEKYslXW1VB/OlILYXgXbxmB3uwMe8nbdmx8JfKK7fpS+t73274O2ErSyU6Efn2cUJK/3ZT+XziiUyD22o06Noeg6hjI1Bt16pE4dNPp3ZGsdVObqkNcxlDzVXYpuldTdCmWqDsXWOhSbq0NbFSzMHBuibc3FZKoOptsY5upgdW2yVqd2vJrWtah56u6u231Rberutrbu/HVuq/hLQWfapLX1EWImfXNTSFNdOqxFDG3nAKbyYy5bj54S2GxQ5kaw3Q0lTTxHfGIF674FrDvXr+5bvrpz9erOxas71+6DG1gDu5DGmWaswj6oMnX9wvrpVAtT416gtUzlr4e8alPjX+dvM/Mv61NLmXpoKcL6zR0JSuP1LczMv2i8c/3H/ur4dL799QvtO5Ru5+P3y8lf/ny7Pv3x6et/L/yEv/C+3J6fTj/ebicobT/z9j9fpY9eY33s3xf3Vy08xBAe8Uvv8ll8kFbwsn9d+FX7r0iaw+M7RvY/", "file_map": { "19": { "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n super::keccakf1600(input)\n }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n if crate::runtime::is_unconstrained() {\n // Temporary measure while Barretenberg is main proving system.\n // Please open an issue if you're working on another proving system and running into problems due to this.\n crate::static_assert(\n N <= 1024,\n \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n );\n }\n __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment(input: [Field; N]) -> EmbeddedCurvePoint {\n // docs:end:pedersen_commitment\n pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator(\n input: [Field; N],\n separator: u32,\n) -> EmbeddedCurvePoint {\n let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n for i in 0..N {\n // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n points[i] = from_field_unsafe(input[i]);\n }\n let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator(input: [Field; N], separator: u32) -> Field {\n let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n let mut generators: [EmbeddedCurvePoint; N + 1] =\n [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n let domain_generators: [EmbeddedCurvePoint; N] =\n derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n for i in 0..N {\n scalars[i] = from_field_unsafe(input[i]);\n generators[i] = domain_generators[i];\n }\n scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n let length_generator: [EmbeddedCurvePoint; 1] =\n derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n generators[N] = length_generator[0];\n multi_scalar_mul_array_return(generators, scalars)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n crate::assert_constant(domain_separator_bytes);\n // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators(\n domain_separator_bytes: [u8; M],\n starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n // Safety: xlo and xhi decomposition is checked below\n let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n // Check that the decomposition is correct\n assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n let mut sum = 0;\n\n for input in inputs {\n let input_bytes: [u8; 32] = input.to_le_bytes();\n sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n }\n\n sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n fn hash(self, state: &mut H)\n where\n H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::hash::Hash };\n let signature = quote { fn hash(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n let for_each_field = |name| quote { _self.$name.hash(_state); };\n crate::meta::make_trait_impl(\n s,\n name,\n signature,\n for_each_field,\n quote {},\n |fields| fields,\n )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n fn finish(self) -> Field;\n\n fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n type H: Hasher;\n\n fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault;\n\nimpl BuildHasher for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n type H = H;\n\n fn build_hasher(_self: Self) -> H {\n H::default()\n }\n}\n\nimpl Default for BuildHasherDefault\nwhere\n H: Hasher + Default,\n{\n fn default() -> Self {\n BuildHasherDefault {}\n }\n}\n\nimpl Hash for Field {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self);\n }\n}\n\nimpl Hash for u1 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for u128 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i8 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i16 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i32 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for i64 {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for bool {\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n H::write(state, self as Field);\n }\n}\n\nimpl Hash for () {\n fn hash(_self: Self, _state: &mut H)\n where\n H: Hasher,\n {}\n}\n\nimpl Hash for [T; N]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for [T]\nwhere\n T: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.len().hash(state);\n for elem in self {\n elem.hash(state);\n }\n }\n}\n\nimpl Hash for (A, B)\nwhere\n A: Hash,\n B: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n }\n}\n\nimpl Hash for (A, B, C)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n }\n}\n\nimpl Hash for (A, B, C, D, E)\nwhere\n A: Hash,\n B: Hash,\n C: Hash,\n D: Hash,\n E: Hash,\n{\n fn hash(self, state: &mut H)\n where\n H: Hasher,\n {\n self.0.hash(state);\n self.1.hash(state);\n self.2.hash(state);\n self.3.hash(state);\n self.4.hash(state);\n }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n assert_eq(\n pedersen_hash_with_separator([1], 1),\n 0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n );\n assert_eq(\n pedersen_commitment_with_separator([1], 1),\n EmbeddedCurvePoint {\n x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n is_infinite: false,\n },\n );\n\n assert_eq(\n pedersen_hash_with_separator([1, 2], 2),\n 0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2], 2),\n EmbeddedCurvePoint {\n x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3], 3),\n 0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3], 3),\n EmbeddedCurvePoint {\n x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4], 4),\n 0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n EmbeddedCurvePoint {\n x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n 0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n EmbeddedCurvePoint {\n x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n 0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n EmbeddedCurvePoint {\n x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n 0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n EmbeddedCurvePoint {\n x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n 0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n EmbeddedCurvePoint {\n x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n 0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n EmbeddedCurvePoint {\n x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n is_infinite: false,\n },\n );\n assert_eq(\n pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n 0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n );\n assert_eq(\n pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n EmbeddedCurvePoint {\n x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n is_infinite: false,\n },\n );\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index f4b9f1e96eb..1e480232f80 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -76,9 +76,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32837) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32842 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32847 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 104 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 161 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(6), location: 157 }, Jump { location: 113 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(7), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Relative(6) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 167 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(7), location: 125 }, Jump { location: 141 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, 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: Direct(32836) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, 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) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 141 }, Load { destination: Relative(6), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 149 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(3) }, Mov { destination: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 177 }, Mov { destination: Direct(0), source: Relative(0) }, Return, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(1), location: 161 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 166 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 161 }, Const { destination: Relative(2), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 172 }, Jump { location: 176 }, Const { destination: Relative(1), bit_size: Field, value: 1 }, Const { destination: Relative(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(3), op: Div, lhs: Relative(1), rhs: Relative(2) }, Jump { location: 176 }, Return, Call { location: 161 }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 184 }, Call { location: 206 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(7), size: 32 } }), Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(3) }, Mov { destination: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 209 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, JumpIf { condition: Relative(1), location: 205 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 161 }, 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(32835) }, 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: 219 }, Call { location: 206 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 225 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, JumpIf { condition: Relative(5), location: 230 }, Jump { location: 228 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(5), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 225 }]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U32) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Cast { destination: Direct(32878), source: Direct(32878), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32837) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32842 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32847 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 104 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32879 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Const { destination: Direct(32835), bit_size: Integer(U1), value: 1 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 162 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, JumpIf { condition: Relative(6), location: 113 }, Jump { location: 118 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Direct(32835) }, JumpIf { condition: Relative(6), location: 117 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 118 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(7), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Relative(6) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(7) }, Call { location: 168 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(7), location: 130 }, Jump { location: 146 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, 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: Direct(32836) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, 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) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 146 }, Load { destination: Relative(6), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 154 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(3) }, Mov { destination: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 178 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 167 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 162 }, Const { destination: Relative(2), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 173 }, Jump { location: 177 }, Const { destination: Relative(1), bit_size: Field, value: 1 }, Const { destination: Relative(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(3), op: Div, lhs: Relative(1), rhs: Relative(2) }, Jump { location: 177 }, Return, Call { location: 162 }, Load { destination: Relative(3), source_pointer: Relative(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 185 }, Call { location: 207 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(3) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(5), size: Relative(6) }, output: HeapArray { pointer: Relative(7), size: 32 } }), Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(3) }, Mov { destination: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 210 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, JumpIf { condition: Relative(1), location: 206 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 162 }, 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(32835) }, 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: 220 }, Call { location: 207 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 226 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, JumpIf { condition: Relative(5), location: 231 }, Jump { location: 229 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(5), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(3) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(6), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(6) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32836) }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 226 }]" ], - "debug_symbols": "pZbNjqpAEIXfhTWLrq7+qfZVJsag4oSEoGH0JjfGd79VQ5V4F0wMs/F8COd0ddMF3Ktju7997rrhdP6qNh/3aj92fd997vrzobl254H/vVdOfsBRtYGatUwKWG28aKg2KBpVk2pWJdUyqee4IAqq7EuiSTWrkmqZFJ0qqHpVVA2qmoeah5qHmoecF1kDqHJOFkVVziHRqJpUsyqpck5hjU4VVL0qqgbVqMo54ATIoCgkZyCnZJFTUcicCrJ8GQ2CAU3BWQsiLYi0INKCSAsiLYi0IOIJgqwEZQMyKArFGYCBN0ADKUhWuESDZJANyKBM4J0zAANvgAaa7MEuBrsY7GLZjpAFgkE0SAbZgAyKguzKCcwl+w/4Rnu0U7LzoAh4AzTgQb0TiAbJgAf1XuAZWBSCJNPjUVfWb7vr2LbSbi8NyG15acZ2uFab4db3dfWn6W/fF31dmuFbr83IZ3m0djiycuCp61uhRz273bIVwKuZ+/Rpj+/7YzF/WueP5s9ujZ9s8rydV/h596nfO1ryx2V/8uZP3q8Z32cbH+GX/lXzD2j+RGvWH218fp6u8GMI6se4Zv6YbP9iykt+2eOLAc4mgIArCojOGiD6xQaA8NMKJttCvJjzPeR2fLeEYGsQ46p7WMhuAj+ew5zwfhM9F4Gf3WVNAMwBPq0JQDdXQL+tYGkK0uyLq+jh2Qr86nhN2PJBc+jG/76uHhI1ds2+b/XwdBsOL2evfy92xr7OLuP50B5vYytJ8ycav4w+iqvBua18p/ER8J6ClOSQ310f3qWan2/bh9TyDw==", + "debug_symbols": "pZbNbuJAEITfxWcO0z3/vEoURQZMZMkyyIGVVoh33+7QBezBEXIu1Gc8VR7a3caXZtdtzp8f/bg/fDXrt0uzmfph6D8/hsO2PfWHUb69NE4/yJVmTSvRelPyzZpVg2k0Taay3qvK+iDKzpRM2dSbBlPJiarppl58WZVM2dSbBtNomkyzaTGtNw2WFywvWF6wvCB5STWZSk5RLaaSU0WjMyVTNvWmkkNOIQISIAMKoBokB9BvtM7ZASSYtKI5ACIA9gJ7IQADPAAbK9hYwcaKbkyLXgqgGlQHIAADPCAANFmLVxMgAwqg3oCdAxCAAR4QAJbMhMWExYTF2pGUFSIgATKgAKqB9ucNCAAX6xq59+xxSpuQqoIHBIDOgVNIgAyQizIrIFCb8QaaXK7XVYPR+zhNXaeT9zSLMqHHdurGU7Mez8Owav60w/l70dexHb/11E5yVq7WjTtRCdz3Q6d0XT3cbt5KxGaW0b3b4+t+n+EPvMQfK/xp0fVjhD+7Jf6C4slcLPBLG5ufXZnzp3l/YvgTL6kfM+ov7fpL/6LfHzz8qSzw+xDM7+OS/fuE/vUpz/m1x2cDHArgyS/YQHRo4MizDUzhpwlKaAEZpsc9kHF8dQsBNYhxyT2QpzRugjynwyPh9SG4F0Ee4nVJAD0COC0J8O6xg/LbHcz9BB3W2Soy3R+F7N1zwrsctNt++u9F66pRU99uhs4O9+dx+3T29PeIM3hRO06Hbbc7T50mPd7W5F/prboVOfeur2xyRDIWlLIeyl/NG0uTs6vvV93LPw==", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap index 1036cc2bbd4..c1026a7172b 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_0.snap @@ -76,9 +76,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 207 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 203 }, Jump { location: 112 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 117 }, Jump { location: 121 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 121 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 127 }, Jump { location: 143 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 143 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 151 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 157 }, Call { location: 213 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 176 }, Call { location: 213 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 182 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 190 }, Jump { location: 185 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 189 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 182 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(1), location: 207 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, 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: 212 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 208 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 112 }, Jump { location: 117 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 116 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Jump { location: 117 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 122 }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 132 }, Jump { location: 148 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 148 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 156 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 162 }, Call { location: 214 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 181 }, Call { location: 214 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 187 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 195 }, Jump { location: 190 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 194 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 187 }, 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: 213 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tZbNbuowEIXfJWsW9vgndl6lQihAqCJFAaVwpSvEu3emzCHtwgil6qbnc5Nz7HFs42u177aX900/Ho4fVfN2rbZTPwz9+2Y47tpzfxz5v9fKyB9rYtXYFWt9V0tVQ6KuaryoV+XnUTSp5ruSrZpalFT5vSyaVPNdnVG1qqTqVL1qUI2qmuc0z2me1zzPeUnUqXKONQIBIBVKab4GJEBWCAbAcdYJEMABPCAAIqAGJIAkB4ZoABZAAAfwgACIAEmWeY0JkBVqSZaSawsggAN4QABEQK2Q4Eryjsxpknfk46YakBQyOs3cKcn0ZgI4AHdKMpk5ACKAA0nmJyftK+c7kDEAyfECHhAAkuNvt1WFlbw5T10nC/nb0uYFf2qnbjxXzXgZhlX1rx0uXy99nNrxS8/txE95sN24Z+XAQz90QrfV7DZlK+8TNfNOeNjD6/6Q4Y/L/AH+2pT8rux33qvfBbvEH1G/i3XJH574TQ2/dUvqT/h4vFoX+MlY9ZNJJX8q+yPBH4mW9E+on5z9pX9R/d7BH4v1yxr/s4BgsAMCFXeA9U+WgIv4BvwrMU8C78eXx+CxikMoFxH/MIAPQmxEPgr9HPFyAh+c+bGUXV6UYOcEiosSnJnHkH49hlIV9ORb8k0EW8KSM4WEZ0eKe/j9zy295la766cf96ebJE19ux06bR4u4+7b0/P/E57g/nWajrtuf5k6SZovYfyD95bNyhqzlpsYt4iPR7IkTStNvlOQDeubjOUT", + "debug_symbols": "tZbNbuowEIXfJess7Bn/8ipVhQKEKlIUUApXukK8+50BH8JdBKFU3XQ+Nz7HHntsfKl27eb8te6G/eG7Wn1cqs3Y9X33te4P2+bUHQb576Uy+seaUK1sLTHeo6VqRRq5RFeiL1H6scZUrbzGfI8kuqiRS3Qlin/SGO+RpZ81CgxwAA8IgAhIgFzAGYAFwNnB2cHZwdmJc9aYSlQ7TdsbgNppop4ADHAAD9CJOoUISIBcIBiABRCAAeocFDwgACIgAXKBaAAWoM66ypEBDqDOmnIMgAhIgFwgGYAFEACqLH1I1zRrH93qTAAGYNAsg5Iub46ABJBBSRaTjAFYgNaiU+D7WGQcQMvRXK91hZpen8a21ZJ+KnIp/WMztsOpWg3nvq+rP01/vnX6PjbDLZ6aUb6KZTvsJIrhvutbpWs9qc281Gol3MRyFh5y/76eI/SOluh9hj4sGt976KOZ07t5PTtX9OztEn3A+nGIc/rwQm+wfmx5Sf4Jm29TWKCXci16MmlOn+f1gaAPtGT/iZA/sf2hflH+jqEPs/lb/kUDb3ACPM2eAOtfHcGAPZDTOC2CnOe35+BQxd7PJxF/0UBuVBxEuVPdZPG2g9zA+VHKnBc52MmBwiIHNtMc0o/nMJcFvdhLS/ZxJRObZ4dPaTTbbvzvJXVVq7FrNn1bmvvzsH36evp7xBe8xI7jYdvuzmOrTtNzTH7nPrKprTGf+iaTllwqNVnWptWmvBfIhs+rzuUf", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 1036cc2bbd4..c1026a7172b 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/conditional_regression_short_circuit/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -76,9 +76,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(2))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(4))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(5))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(6))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(7))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(8))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(9))], q_c: 0 }]), Array([Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(11))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(13))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(14))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(16))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(17))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(18))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(20))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(21))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(23))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(24))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(26))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(27))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(28))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(29))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(30))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(31))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(32))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(33))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(35))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(36))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(38))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(39))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 }, Expression { mul_terms: [], linear_combinations: [(1, Witness(41))], q_c: 0 }])], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 207 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 203 }, Jump { location: 112 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 117 }, Jump { location: 121 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 121 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 127 }, Jump { location: 143 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 143 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 151 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 157 }, Call { location: 213 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 176 }, Call { location: 213 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 182 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 190 }, Jump { location: 185 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 189 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 182 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(1), location: 207 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, 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: 212 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 42 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(5), offset_address: Relative(6) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U32) }, Cast { destination: Direct(32839), source: Direct(32839), bit_size: Integer(U32) }, Cast { destination: Direct(32840), source: Direct(32840), bit_size: Integer(U32) }, Cast { destination: Direct(32841), source: Direct(32841), bit_size: Integer(U8) }, Cast { destination: Direct(32842), source: Direct(32842), bit_size: Integer(U8) }, Cast { destination: Direct(32843), source: Direct(32843), bit_size: Integer(U8) }, Cast { destination: Direct(32844), source: Direct(32844), bit_size: Integer(U8) }, Cast { destination: Direct(32845), source: Direct(32845), bit_size: Integer(U8) }, Cast { destination: Direct(32846), source: Direct(32846), bit_size: Integer(U8) }, Cast { destination: Direct(32847), source: Direct(32847), bit_size: Integer(U8) }, Cast { destination: Direct(32848), source: Direct(32848), bit_size: Integer(U8) }, Cast { destination: Direct(32849), source: Direct(32849), bit_size: Integer(U8) }, Cast { destination: Direct(32850), source: Direct(32850), bit_size: Integer(U8) }, Cast { destination: Direct(32851), source: Direct(32851), bit_size: Integer(U8) }, Cast { destination: Direct(32852), source: Direct(32852), bit_size: Integer(U8) }, Cast { destination: Direct(32853), source: Direct(32853), bit_size: Integer(U8) }, Cast { destination: Direct(32854), source: Direct(32854), bit_size: Integer(U8) }, Cast { destination: Direct(32855), source: Direct(32855), bit_size: Integer(U8) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U8) }, Cast { destination: Direct(32857), source: Direct(32857), bit_size: Integer(U8) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U8) }, Cast { destination: Direct(32859), source: Direct(32859), bit_size: Integer(U8) }, Cast { destination: Direct(32860), source: Direct(32860), bit_size: Integer(U8) }, Cast { destination: Direct(32861), source: Direct(32861), bit_size: Integer(U8) }, Cast { destination: Direct(32862), source: Direct(32862), bit_size: Integer(U8) }, Cast { destination: Direct(32863), source: Direct(32863), bit_size: Integer(U8) }, Cast { destination: Direct(32864), source: Direct(32864), bit_size: Integer(U8) }, Cast { destination: Direct(32865), source: Direct(32865), bit_size: Integer(U8) }, Cast { destination: Direct(32866), source: Direct(32866), bit_size: Integer(U8) }, Cast { destination: Direct(32867), source: Direct(32867), bit_size: Integer(U8) }, Cast { destination: Direct(32868), source: Direct(32868), bit_size: Integer(U8) }, Cast { destination: Direct(32869), source: Direct(32869), bit_size: Integer(U8) }, Cast { destination: Direct(32870), source: Direct(32870), bit_size: Integer(U8) }, Cast { destination: Direct(32871), source: Direct(32871), bit_size: Integer(U8) }, Cast { destination: Direct(32872), source: Direct(32872), bit_size: Integer(U8) }, Cast { destination: Direct(32873), source: Direct(32873), bit_size: Integer(U8) }, Cast { destination: Direct(32874), source: Direct(32874), bit_size: Integer(U8) }, Cast { destination: Direct(32875), source: Direct(32875), bit_size: Integer(U8) }, Cast { destination: Direct(32876), source: Direct(32876), bit_size: Integer(U8) }, Cast { destination: Direct(32877), source: Direct(32877), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(2), source: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(3), source: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 32846 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Mov { destination: Direct(32772), source: Relative(7) }, Mov { destination: Direct(32773), source: Relative(6) }, Call { location: 90 }, Mov { destination: Relative(4), source: Relative(5) }, Call { location: 101 }, Call { location: 102 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32878 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 100 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 93 }, Return, Return, Call { location: 208 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 35 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(6), location: 112 }, Jump { location: 117 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(7) }, JumpIf { condition: Relative(6), location: 116 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Jump { location: 117 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Const { destination: Relative(8), bit_size: Field, value: 15 }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(6), rhs: Relative(8) }, JumpIf { condition: Relative(9), location: 122 }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Field, value: 1 }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Relative(9), op: Div, lhs: Relative(6), rhs: Relative(8) }, Jump { location: 126 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(6) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(8), location: 132 }, Jump { location: 148 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(10), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Relative(12), source: Relative(11) }, Store { destination_pointer: Relative(12), source: Relative(1) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(9) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(6) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Jump { location: 148 }, Load { destination: Relative(8), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(9) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U1, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 156 }, 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(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 162 }, Call { location: 214 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(2) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 33 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 5 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BlackBox(Blake3 { message: HeapVector { pointer: Relative(8), size: Relative(9) }, output: HeapArray { pointer: Relative(10), size: 32 } }), Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(2) }, 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: 181 }, Call { location: 214 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 32 }, Mov { destination: Relative(6), source: Relative(8) }, Jump { location: 187 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(10) }, JumpIf { condition: Relative(5), location: 195 }, Jump { location: 190 }, Load { destination: Relative(1), source_pointer: Relative(3) }, JumpIf { condition: Relative(1), location: 194 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Return, Load { destination: Relative(5), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(8), rhs: Relative(9) }, BinaryIntOp { destination: Relative(8), op: Mul, bit_size: U1, lhs: Relative(5), rhs: Relative(11) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Mov { destination: Relative(6), source: Relative(5) }, Jump { location: 187 }, 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: 213 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tZbNbuowEIXfJWsW9vgndl6lQihAqCJFAaVwpSvEu3emzCHtwgil6qbnc5Nz7HFs42u177aX900/Ho4fVfN2rbZTPwz9+2Y47tpzfxz5v9fKyB9rYtXYFWt9V0tVQ6KuaryoV+XnUTSp5ruSrZpalFT5vSyaVPNdnVG1qqTqVL1qUI2qmuc0z2me1zzPeUnUqXKONQIBIBVKab4GJEBWCAbAcdYJEMABPCAAIqAGJIAkB4ZoABZAAAfwgACIAEmWeY0JkBVqSZaSawsggAN4QABEQK2Q4Eryjsxpknfk46YakBQyOs3cKcn0ZgI4AHdKMpk5ACKAA0nmJyftK+c7kDEAyfECHhAAkuNvt1WFlbw5T10nC/nb0uYFf2qnbjxXzXgZhlX1rx0uXy99nNrxS8/txE95sN24Z+XAQz90QrfV7DZlK+8TNfNOeNjD6/6Q4Y/L/AH+2pT8rux33qvfBbvEH1G/i3XJH574TQ2/dUvqT/h4vFoX+MlY9ZNJJX8q+yPBH4mW9E+on5z9pX9R/d7BH4v1yxr/s4BgsAMCFXeA9U+WgIv4BvwrMU8C78eXx+CxikMoFxH/MIAPQmxEPgr9HPFyAh+c+bGUXV6UYOcEiosSnJnHkH49hlIV9ORb8k0EW8KSM4WEZ0eKe/j9zy295la766cf96ebJE19ux06bR4u4+7b0/P/E57g/nWajrtuf5k6SZovYfyD95bNyhqzlpsYt4iPR7IkTStNvlOQDeubjOUT", + "debug_symbols": "tZbNbuowEIXfJess7Bn/8ipVhQKEKlIUUApXukK8+50BH8JdBKFU3XQ+Nz7HHntsfKl27eb8te6G/eG7Wn1cqs3Y9X33te4P2+bUHQb576Uy+seaUK1sLTHeo6VqRRq5RFeiL1H6scZUrbzGfI8kuqiRS3Qlin/SGO+RpZ81CgxwAA8IgAhIgFzAGYAFwNnB2cHZwdmJc9aYSlQ7TdsbgNppop4ADHAAD9CJOoUISIBcIBiABRCAAeocFDwgACIgAXKBaAAWoM66ypEBDqDOmnIMgAhIgFwgGYAFEACqLH1I1zRrH93qTAAGYNAsg5Iub46ABJBBSRaTjAFYgNaiU+D7WGQcQMvRXK91hZpen8a21ZJ+KnIp/WMztsOpWg3nvq+rP01/vnX6PjbDLZ6aUb6KZTvsJIrhvutbpWs9qc281Gol3MRyFh5y/76eI/SOluh9hj4sGt976KOZ07t5PTtX9OztEn3A+nGIc/rwQm+wfmx5Sf4Jm29TWKCXci16MmlOn+f1gaAPtGT/iZA/sf2hflH+jqEPs/lb/kUDb3ACPM2eAOtfHcGAPZDTOC2CnOe35+BQxd7PJxF/0UBuVBxEuVPdZPG2g9zA+VHKnBc52MmBwiIHNtMc0o/nMJcFvdhLS/ZxJRObZ4dPaTTbbvzvJXVVq7FrNn1bmvvzsH36evp7xBe8xI7jYdvuzmOrTtNzTH7nPrKprTGf+iaTllwqNVnWptWmvBfIhs+rzuUf", "file_map": { "5": { "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n let for_each_field = |name| quote { (_self.$name == _other.$name) };\n let body = |fields| {\n if s.fields_as_written().len() == 0 {\n quote { true }\n } else {\n fields\n }\n };\n crate::meta::make_trait_impl(\n s,\n quote { $crate::cmp::Eq },\n signature,\n for_each_field,\n quote { & },\n body,\n )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n fn eq(self, other: Field) -> bool {\n self == other\n }\n}\n\nimpl Eq for u128 {\n fn eq(self, other: u128) -> bool {\n self == other\n }\n}\nimpl Eq for u64 {\n fn eq(self, other: u64) -> bool {\n self == other\n }\n}\nimpl Eq for u32 {\n fn eq(self, other: u32) -> bool {\n self == other\n }\n}\nimpl Eq for u16 {\n fn eq(self, other: u16) -> bool {\n self == other\n }\n}\nimpl Eq for u8 {\n fn eq(self, other: u8) -> bool {\n self == other\n }\n}\nimpl Eq for u1 {\n fn eq(self, other: u1) -> bool {\n self == other\n }\n}\n\nimpl Eq for i8 {\n fn eq(self, other: i8) -> bool {\n self == other\n }\n}\nimpl Eq for i16 {\n fn eq(self, other: i16) -> bool {\n self == other\n }\n}\nimpl Eq for i32 {\n fn eq(self, other: i32) -> bool {\n self == other\n }\n}\nimpl Eq for i64 {\n fn eq(self, other: i64) -> bool {\n self == other\n }\n}\n\nimpl Eq for () {\n fn eq(_self: Self, _other: ()) -> bool {\n true\n }\n}\nimpl Eq for bool {\n fn eq(self, other: bool) -> bool {\n self == other\n }\n}\n\nimpl Eq for [T; N]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T; N]) -> bool {\n let mut result = true;\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for [T]\nwhere\n T: Eq,\n{\n fn eq(self, other: [T]) -> bool {\n let mut result = self.len() == other.len();\n for i in 0..self.len() {\n result &= self[i].eq(other[i]);\n }\n result\n }\n}\n\nimpl Eq for str {\n fn eq(self, other: str) -> bool {\n let self_bytes = self.as_bytes();\n let other_bytes = other.as_bytes();\n self_bytes == other_bytes\n }\n}\n\nimpl Eq for (A, B)\nwhere\n A: Eq,\n B: Eq,\n{\n fn eq(self, other: (A, B)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1)\n }\n}\n\nimpl Eq for (A, B, C)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n{\n fn eq(self, other: (A, B, C)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n }\n}\n\nimpl Eq for (A, B, C, D)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n{\n fn eq(self, other: (A, B, C, D)) -> bool {\n self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n }\n}\n\nimpl Eq for (A, B, C, D, E)\nwhere\n A: Eq,\n B: Eq,\n C: Eq,\n D: Eq,\n E: Eq,\n{\n fn eq(self, other: (A, B, C, D, E)) -> bool {\n self.0.eq(other.0)\n & self.1.eq(other.1)\n & self.2.eq(other.2)\n & self.3.eq(other.3)\n & self.4.eq(other.4)\n }\n}\n\nimpl Eq for Ordering {\n fn eq(self, other: Ordering) -> bool {\n self.result == other.result\n }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n result: Field,\n}\n\nimpl Ordering {\n // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n // into the compiler, do not change these without also updating\n // the compiler itself!\n pub fn less() -> Ordering {\n Ordering { result: 0 }\n }\n\n pub fn equal() -> Ordering {\n Ordering { result: 1 }\n }\n\n pub fn greater() -> Ordering {\n Ordering { result: 2 }\n }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n let name = quote { $crate::cmp::Ord };\n let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n let for_each_field = |name| quote {\n if result == $crate::cmp::Ordering::equal() {\n result = _self.$name.cmp(_other.$name);\n }\n };\n let body = |fields| quote {\n let mut result = $crate::cmp::Ordering::equal();\n $fields\n result\n };\n crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n fn cmp(self, other: u128) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\nimpl Ord for u64 {\n fn cmp(self, other: u64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u32 {\n fn cmp(self, other: u32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u16 {\n fn cmp(self, other: u16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for u8 {\n fn cmp(self, other: u8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i8 {\n fn cmp(self, other: i8) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i16 {\n fn cmp(self, other: i16) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i32 {\n fn cmp(self, other: i32) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for i64 {\n fn cmp(self, other: i64) -> Ordering {\n if self < other {\n Ordering::less()\n } else if self > other {\n Ordering::greater()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for () {\n fn cmp(_self: Self, _other: ()) -> Ordering {\n Ordering::equal()\n }\n}\n\nimpl Ord for bool {\n fn cmp(self, other: bool) -> Ordering {\n if self {\n if other {\n Ordering::equal()\n } else {\n Ordering::greater()\n }\n } else if other {\n Ordering::less()\n } else {\n Ordering::equal()\n }\n }\n}\n\nimpl Ord for [T; N]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T; N]) -> Ordering {\n let mut result = Ordering::equal();\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for [T]\nwhere\n T: Ord,\n{\n // The first non-equal element of both arrays determines\n // the ordering for the whole array.\n fn cmp(self, other: [T]) -> Ordering {\n let mut result = self.len().cmp(other.len());\n for i in 0..self.len() {\n if result == Ordering::equal() {\n result = self[i].cmp(other[i]);\n }\n }\n result\n }\n}\n\nimpl Ord for (A, B)\nwhere\n A: Ord,\n B: Ord,\n{\n fn cmp(self, other: (A, B)) -> Ordering {\n let result = self.0.cmp(other.0);\n\n if result != Ordering::equal() {\n result\n } else {\n self.1.cmp(other.1)\n }\n }\n}\n\nimpl Ord for (A, B, C)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n{\n fn cmp(self, other: (A, B, C)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n{\n fn cmp(self, other: (A, B, C, D)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n result\n }\n}\n\nimpl Ord for (A, B, C, D, E)\nwhere\n A: Ord,\n B: Ord,\n C: Ord,\n D: Ord,\n E: Ord,\n{\n fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n let mut result = self.0.cmp(other.0);\n\n if result == Ordering::equal() {\n result = self.1.cmp(other.1);\n }\n\n if result == Ordering::equal() {\n result = self.2.cmp(other.2);\n }\n\n if result == Ordering::equal() {\n result = self.3.cmp(other.3);\n }\n\n if result == Ordering::equal() {\n result = self.4.cmp(other.4);\n }\n\n result\n }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v1\n } else {\n v2\n }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min(v1: T, v2: T) -> T\nwhere\n T: Ord,\n{\n if v1 > v2 {\n v2\n } else {\n v1\n }\n}\n\nmod cmp_tests {\n use crate::cmp::{max, min};\n\n #[test]\n fn sanity_check_min() {\n assert_eq(min(0 as u64, 1 as u64), 0);\n assert_eq(min(0 as u64, 0 as u64), 0);\n assert_eq(min(1 as u64, 1 as u64), 1);\n assert_eq(min(255 as u8, 0 as u8), 0);\n }\n\n #[test]\n fn sanity_check_max() {\n assert_eq(max(0 as u64, 1 as u64), 1);\n assert_eq(max(0 as u64, 0 as u64), 0);\n assert_eq(max(1 as u64, 1 as u64), 1);\n assert_eq(max(255 as u8, 0 as u8), 255);\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 45d0957c24b..f03f0a18368 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -40,7 +40,7 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _71", + "current witness index : _68", "private parameters indices : [_0]", "public parameters indices : []", "return value indices : []", @@ -60,96 +60,92 @@ expression: artifact "EXPR [ (1, _7, _9) 0 ]", "BRILLIG CALL func 0: PREDICATE = EXPR [ (1, _9) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Array([Expression { mul_terms: [], linear_combinations: [], q_c: 104 }, Expression { mul_terms: [], linear_combinations: [], q_c: 105 }])], outputs: []", - "EXPR [ (1, _5, _6) (8, _2) (-1, _10) -9 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 })], outputs: [Simple(Witness(11))]", - "EXPR [ (1, _10, _11) (1, _12) -1 ]", - "EXPR [ (1, _10, _12) 0 ]", - "BRILLIG CALL func 1: PREDICATE = EXPR [ (-1, _9, _12) (1, _12) 0 ]", + "EXPR [ (1, _5, _6) (8, _2) (-1, _10) 0 ]", + "EXPR [ (-1, _9) (-1, _11) 1 ]", + "EXPR [ (1, _10, _11) (-9, _11) 0 ]", + "BRILLIG CALL func 1: PREDICATE = EXPR [ (1, _11) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Array([Expression { mul_terms: [], linear_combinations: [], q_c: 98 }, Expression { mul_terms: [], linear_combinations: [], q_c: 121 }, Expression { mul_terms: [], linear_combinations: [], q_c: 101 }])], outputs: []", - "EXPR [ (1, _5, _6) (8, _2) (-1, _13) 0 ]", - "EXPR [ (1, _9, _12) (-1, _9) (-1, _12) (-1, _14) 1 ]", - "EXPR [ (1, _13, _14) (-11, _14) 0 ]", - "EXPR [ (1, _0) (-1, _15) -1 ]", - "BLACKBOX::RANGE [(_15, 32)] []", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 })], outputs: [Simple(Witness(16))]", - "EXPR [ (1, _15, _16) (1, _17) -1 ]", - "EXPR [ (1, _15, _17) 0 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: -1 })], outputs: [Simple(Witness(18))]", - "EXPR [ (1, _15, _18) (-1, _18) (1, _19) -1 ]", - "EXPR [ (1, _15, _19) (-1, _19) 0 ]", - "EXPR [ (-1, _17) (-1, _20) 1 ]", - "EXPR [ (1, _17, _19) (-6, _17) (-1, _19) (-1, _21) 6 ]", - "EXPR [ (1, _20, _21) (4, _17) (-1, _22) -4 ]", + "EXPR [ (1, _0) (-1, _12) -1 ]", + "BLACKBOX::RANGE [(_12, 32)] []", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 })], outputs: [Simple(Witness(13))]", + "EXPR [ (1, _12, _13) (1, _14) -1 ]", + "EXPR [ (1, _12, _14) 0 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: -1 })], outputs: [Simple(Witness(15))]", + "EXPR [ (1, _12, _15) (-1, _15) (1, _16) -1 ]", + "EXPR [ (1, _12, _16) (-1, _16) 0 ]", + "EXPR [ (-1, _14) (-1, _17) 1 ]", + "EXPR [ (1, _14, _16) (-6, _14) (-1, _16) (-1, _18) 6 ]", + "EXPR [ (1, _17, _18) (4, _14) (-1, _19) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 })], outputs: [Simple(Witness(20))]", + "EXPR [ (1, _19, _20) (1, _21) -1 ]", + "EXPR [ (1, _19, _21) 0 ]", + "EXPR [ (1, _17, _18) (4, _14) (-1, _22) -5 ]", "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 })], outputs: [Simple(Witness(23))]", "EXPR [ (1, _22, _23) (1, _24) -1 ]", "EXPR [ (1, _22, _24) 0 ]", - "EXPR [ (1, _20, _21) (4, _17) (-1, _25) -5 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 })], outputs: [Simple(Witness(26))]", - "EXPR [ (1, _25, _26) (1, _27) -1 ]", - "EXPR [ (1, _25, _27) 0 ]", - "EXPR [ (1, _15) (-1, _28) 1 ]", - "EXPR [ (-1, _24, _27) (1, _27) (-1, _29) 0 ]", - "EXPR [ (1, _28, _29) (-1, _30) 0 ]", + "EXPR [ (1, _12) (-1, _25) 1 ]", + "EXPR [ (-1, _21, _24) (1, _24) (-1, _26) 0 ]", + "EXPR [ (1, _25, _26) (-1, _27) 0 ]", + "BLACKBOX::RANGE [(_27, 32)] []", + "EXPR [ (1, _17, _18) (4, _14) (-1, _28) 0 ]", + "EXPR [ (1, _21, _24) (-1, _21) (-1, _24) (-1, _29) 1 ]", + "EXPR [ (1, _28, _29) (-6, _29) 0 ]", + "EXPR [ (1, _12, _29) (2, _29) (-1, _30) 0 ]", "BLACKBOX::RANGE [(_30, 32)] []", - "EXPR [ (1, _20, _21) (4, _17) (-1, _31) 0 ]", - "EXPR [ (1, _24, _27) (-1, _24) (-1, _27) (-1, _32) 1 ]", - "EXPR [ (1, _31, _32) (-6, _32) 0 ]", - "EXPR [ (1, _15, _32) (2, _32) (-1, _33) 0 ]", - "BLACKBOX::RANGE [(_33, 32)] []", - "EXPR [ (-1, _24) (-1, _34) 1 ]", - "EXPR [ (1, _29, _30) (1, _32, _33) (-1, _35) 0 ]", - "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(24), Witness(15)), (1, Witness(34), Witness(35))], linear_combinations: [], q_c: 0 })], outputs: []", - "EXPR [ (-5, _2, _4) (5, _4) (-1, _36) 0 ]", - "EXPR [ (1, _5, _36) (4, _2) (-1, _37) -4 ]", + "EXPR [ (-1, _21) (-1, _31) 1 ]", + "EXPR [ (1, _26, _27) (1, _29, _30) (-1, _32) 0 ]", + "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(21), Witness(12)), (1, Witness(31), Witness(32))], linear_combinations: [], q_c: 0 })], outputs: []", + "EXPR [ (-5, _2, _4) (5, _4) (-1, _33) 0 ]", + "EXPR [ (1, _5, _33) (4, _2) (-1, _34) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 })], outputs: [Simple(Witness(35))]", + "EXPR [ (1, _34, _35) (1, _36) -1 ]", + "EXPR [ (1, _34, _36) 0 ]", + "EXPR [ (1, _5, _33) (4, _2) (-1, _37) -5 ]", "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 })], outputs: [Simple(Witness(38))]", "EXPR [ (1, _37, _38) (1, _39) -1 ]", "EXPR [ (1, _37, _39) 0 ]", - "EXPR [ (1, _5, _36) (4, _2) (-1, _40) -5 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 })], outputs: [Simple(Witness(41))]", - "EXPR [ (1, _40, _41) (1, _42) -1 ]", - "EXPR [ (1, _40, _42) 0 ]", - "EXPR [ (1, _0) (-1, _43) 1 ]", - "EXPR [ (-1, _39, _42) (1, _42) (-1, _44) 0 ]", - "EXPR [ (1, _43, _44) (-1, _45) 0 ]", + "EXPR [ (1, _0) (-1, _40) 1 ]", + "EXPR [ (-1, _36, _39) (1, _39) (-1, _41) 0 ]", + "EXPR [ (1, _40, _41) (-1, _42) 0 ]", + "BLACKBOX::RANGE [(_42, 32)] []", + "EXPR [ (1, _5, _33) (4, _2) (-1, _43) 0 ]", + "EXPR [ (1, _36, _39) (-1, _36) (-1, _39) (-1, _44) 1 ]", + "EXPR [ (1, _43, _44) (-6, _44) 0 ]", + "EXPR [ (1, _0, _44) (2, _44) (-1, _45) 0 ]", "BLACKBOX::RANGE [(_45, 32)] []", - "EXPR [ (1, _5, _36) (4, _2) (-1, _46) 0 ]", - "EXPR [ (1, _39, _42) (-1, _39) (-1, _42) (-1, _47) 1 ]", - "EXPR [ (1, _46, _47) (-6, _47) 0 ]", - "EXPR [ (1, _0, _47) (2, _47) (-1, _48) 0 ]", + "EXPR [ (-1, _36) (-1, _46) 1 ]", + "EXPR [ (1, _41, _42) (1, _44, _45) (-1, _47) 0 ]", + "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(36), Witness(0)), (1, Witness(46), Witness(47))], linear_combinations: [], q_c: 0 })], outputs: []", + "EXPR [ (1, _0) (-1, _48) 1 ]", "BLACKBOX::RANGE [(_48, 32)] []", - "EXPR [ (-1, _39) (-1, _49) 1 ]", - "EXPR [ (1, _44, _45) (1, _47, _48) (-1, _50) 0 ]", - "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(39), Witness(0)), (1, Witness(49), Witness(50))], linear_combinations: [], q_c: 0 })], outputs: []", - "EXPR [ (1, _0) (-1, _51) 1 ]", - "BLACKBOX::RANGE [(_51, 32)] []", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(51))], q_c: 0 })], outputs: [Simple(Witness(52))]", - "EXPR [ (1, _51, _52) (1, _53) -1 ]", - "EXPR [ (1, _51, _53) 0 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(51))], q_c: -1 })], outputs: [Simple(Witness(54))]", - "EXPR [ (1, _51, _54) (-1, _54) (1, _55) -1 ]", - "EXPR [ (1, _51, _55) (-1, _55) 0 ]", - "EXPR [ (-1, _53) (-1, _56) 1 ]", - "EXPR [ (1, _53, _55) (-6, _53) (-1, _55) (-1, _57) 6 ]", - "EXPR [ (1, _56, _57) (4, _53) (-1, _58) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(48))], q_c: 0 })], outputs: [Simple(Witness(49))]", + "EXPR [ (1, _48, _49) (1, _50) -1 ]", + "EXPR [ (1, _48, _50) 0 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(48))], q_c: -1 })], outputs: [Simple(Witness(51))]", + "EXPR [ (1, _48, _51) (-1, _51) (1, _52) -1 ]", + "EXPR [ (1, _48, _52) (-1, _52) 0 ]", + "EXPR [ (-1, _50) (-1, _53) 1 ]", + "EXPR [ (1, _50, _52) (-6, _50) (-1, _52) (-1, _54) 6 ]", + "EXPR [ (1, _53, _54) (4, _50) (-1, _55) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(55))], q_c: 0 })], outputs: [Simple(Witness(56))]", + "EXPR [ (1, _55, _56) (1, _57) -1 ]", + "EXPR [ (1, _55, _57) 0 ]", + "EXPR [ (1, _53, _54) (4, _50) (-1, _58) -5 ]", "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(58))], q_c: 0 })], outputs: [Simple(Witness(59))]", "EXPR [ (1, _58, _59) (1, _60) -1 ]", "EXPR [ (1, _58, _60) 0 ]", - "EXPR [ (1, _56, _57) (4, _53) (-1, _61) -5 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(61))], q_c: 0 })], outputs: [Simple(Witness(62))]", - "EXPR [ (1, _61, _62) (1, _63) -1 ]", - "EXPR [ (1, _61, _63) 0 ]", - "EXPR [ (1, _51) (-1, _64) 1 ]", - "EXPR [ (-1, _60, _63) (1, _63) (-1, _65) 0 ]", - "EXPR [ (1, _64, _65) (-1, _66) 0 ]", + "EXPR [ (1, _48) (-1, _61) 1 ]", + "EXPR [ (-1, _57, _60) (1, _60) (-1, _62) 0 ]", + "EXPR [ (1, _61, _62) (-1, _63) 0 ]", + "BLACKBOX::RANGE [(_63, 32)] []", + "EXPR [ (1, _53, _54) (4, _50) (-1, _64) 0 ]", + "EXPR [ (1, _57, _60) (-1, _57) (-1, _60) (-1, _65) 1 ]", + "EXPR [ (1, _64, _65) (-6, _65) 0 ]", + "EXPR [ (1, _48, _65) (2, _65) (-1, _66) 0 ]", "BLACKBOX::RANGE [(_66, 32)] []", - "EXPR [ (1, _56, _57) (4, _53) (-1, _67) 0 ]", - "EXPR [ (1, _60, _63) (-1, _60) (-1, _63) (-1, _68) 1 ]", - "EXPR [ (1, _67, _68) (-6, _68) 0 ]", - "EXPR [ (1, _51, _68) (2, _68) (-1, _69) 0 ]", - "BLACKBOX::RANGE [(_69, 32)] []", - "EXPR [ (-1, _60) (-1, _70) 1 ]", - "EXPR [ (1, _65, _66) (1, _68, _69) (-1, _71) 0 ]", - "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(60), Witness(51)), (1, Witness(70), Witness(71))], linear_combinations: [], q_c: 0 })], outputs: []", + "EXPR [ (-1, _57) (-1, _67) 1 ]", + "EXPR [ (1, _62, _63) (1, _65, _66) (-1, _68) 0 ]", + "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(57), Witness(48)), (1, Witness(67), Witness(68))], linear_combinations: [], q_c: 0 })], outputs: []", "unconstrained func 0", "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U1) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 27 }, Mov { destination: Relative(2), source: Relative(3) }, Call { location: 38 }, Call { location: 39 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 37 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 30 }, Return, Return, Call { location: 123 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 125 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(22), source: Relative(21) }, Store { destination_pointer: Relative(22), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(5) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(6) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(7) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(8) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(9) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(10) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(12) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(6) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(7) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(13) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(14) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(15) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(7) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(13) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(17) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(9) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(18) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Const { destination: Relative(3), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(4), size: 2 }), HeapArray(HeapArray { pointer: Relative(5), size: 28 }), MemoryAddress(Relative(3))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, 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: 128 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", @@ -159,7 +155,7 @@ expression: artifact "unconstrained func 3", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLRSNb2o8UuSty9Lp5Gh+uP+4Pp+/PPzff7l43D+fD8Xj4cX98ftxfDs+n+u/rZrBDqEe33QQHEYiHBEiEJEiGFIg2iaBEUCIoEZQISgQlghJBiaBEUBIoCZQESgIlgZJASaAkUBIoCZQMSgYlg5JByaBkUDIoGZQMSgalgFJAKaAUUAooBZQCSgGlgFJAUVAUFAVFQVFQFBQFRUFRUBQUNwxURxWqpwZqpCZqphYqeY48R54jz5HnyHPkOfIcea7yxFShMlArT97qScusr5T6Sqn/Sik3lVKmgtQSS60exBh0QdADQQcE7QuaF7QuaFzQtoAioAgoHhQPigfFg+JB8aB4UDwoHhQPytdb9asEZktAWALCEpC3mtt9db6/nMfR8vyv5bou4i/783i6bL6drsfjdvNrf7y2m36+7E9NL/tzvTpsN+PpqWoFfj8cRzt7275HD9OhRR2DVfwtXOSj8TlkxucyLIgXYXiQW3T8t/d+OtpLZLj3bkl81B6f4oL4MPShD26y/TQzev3pc75FB//h1sXfBi9NtV5Wzt1MvKTevuTJ9t3a5Curhm+u+xr65A9lsvv+82pH+/DpZPMz0TH1aJ3s/EzqpaGnfnJxESD07qewrAda+vQNk8XvdGYEQh+CGOMiQOmPEFUWTEHoD1DXlalwe8F9VgLV5aV3IPrJDoSVU2Dv2FVTMAtYOQV1hb4NQZjsQPm8OZChL0HihiUPkMotfnoJcysLeRbwkUKeBXwki3xYmUWzgLVZlIbbJEw/QV6SRbv6a/94OP/7HaZuF0MzNvXo2zHU9ur+vR1TO9YtYratZlvEbINpIhAPsd2lbS8jfiZIhhSI7VQDrFKBVSqwSoVWKdIrRZqlTLeUaZcy/VKhYSp0TIUmSemSlDZJ6ZOURknplJRWSemVFGZJBrilpp4aqOQF8gJ55pmEpkm6a4q0TRG+yTZH5pjs7WOWqWmiZmqhKtR8U1NHNU6CdWoaqJFKXiIvkWcGSjIcVFOH+zN5ZqJE4aL8ABvVNNmeFkaqaaGq7XDhpZo6akBdmIFqmqiZWqgKNRfV1FHF9sAwUk0DNVLJU/KUPLNTPtFP4cThCZqjwokxbWPza38+7B+OoyW+lcb19NjroP68/H7pV/oXy5fz8+P4dD2PVjPvny0r764Ops87VMWdq1PspOz616d2Q9n68n5DqDfo7vYNof1ZE6he2L1Zbf4B", + "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLRWNZ2o8UuRR39Lp5Gh+uP+4Pp+/PPzff7l43D+fD8Xj4cX98ftxfDs+n+u/rZrBDqEe33QQHEYiHBEiEJEiGFIg2iaBEUCIoEZQISgQlghJBiaBEUBIoCZQESgIlgZJASaAkUBIoCZQMSgYlg5JByaBkUDIoGZQMSgalgFJAKaAUUAooBZQCSgGlgFJAUVAUFAVFQVFQFBQFRUFRUBQUNwxURxWqpwZqpCZqphYqeY48R54jz5HnyHPkOfIcea7yxFShMlArT97qj5ZZXyn1lVL/lVJuKqVMBaklllo9iDHogqAHgg4I2hc0L2hd0LigbQFFQBFQPCgeFA+KB8WD4kHxoHhQPCgelK+36tcSmF0CwiUgXALyVnO77873l/M4Wp7/tV3XTfxlfx5Pl8230/V43G5+7Y/XdtPPl/2p6WV/rleH7WY8PVWtwO+H42i/3rbv0cN0aFHHYBV/Cxf5aHwOmfG5DAviRRge5BYd/+29n472EhnuvVsSH7XHp7ggPgx96IObbD/NjF5/+pxv0cF/uHXxt8FLU62XlXM3Ey+pty95sn23NvnKquGb676GPvlDmey+/7y1o334dLL5meiYerROdn4m9dLQUz+5uAgQevdTWNYDLX36hsnF73RmBEIfghjjIkDpjxBVFkxB6A9Q95WpcHvBfVYC1e2ldyD6yQ6ElVNg79hVUzALWDkFdYe+DUGY7ED5vDmQoW9B4oYlD5DKLX56C3MrF/Is4CMLeRbwkSzyYWUWzQLWZlEabpMw/QR5SRbt6tn+8XD+9ztMLRdDMzb16Nsx1PZq/d6OqR1riZit1GybmBWYJgLxEKsurbyMOE2QDLFSNdAqRXqlSLOU6ZYy7VKmXyo0TIWOqdAkKV2S0iYpfZLSKCmdktIqKb2SwizJALfUVKHml5qSF8gL5JlnEpom6a4p0jZF+CYrgMwx2RvGLFNToXpqoEZqomaqcRKsk6l5p6aOSl4iL5FnBkoyHFTTzPvJMxMlChflB9iopmJ1K4xU00CNVsXCSzXNUPNPlvtmoJoK1VMDNVITNVOL1bkwUqbmpJo6KnlKnpJndson+KmmGf03R9XUeFa4/NqfD/uH42iJbal/PT32PK+nl98v/Ur/Ivlyfn4cn67n0dbE+2fJ2v5dHUifd8j6O1en10nZ9a9L7Yay9eX9hlBv0N3tG0H7syZPvbB7s7X3Bw==", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_0.snap index 45d0957c24b..f03f0a18368 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_0.snap @@ -40,7 +40,7 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _71", + "current witness index : _68", "private parameters indices : [_0]", "public parameters indices : []", "return value indices : []", @@ -60,96 +60,92 @@ expression: artifact "EXPR [ (1, _7, _9) 0 ]", "BRILLIG CALL func 0: PREDICATE = EXPR [ (1, _9) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Array([Expression { mul_terms: [], linear_combinations: [], q_c: 104 }, Expression { mul_terms: [], linear_combinations: [], q_c: 105 }])], outputs: []", - "EXPR [ (1, _5, _6) (8, _2) (-1, _10) -9 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 })], outputs: [Simple(Witness(11))]", - "EXPR [ (1, _10, _11) (1, _12) -1 ]", - "EXPR [ (1, _10, _12) 0 ]", - "BRILLIG CALL func 1: PREDICATE = EXPR [ (-1, _9, _12) (1, _12) 0 ]", + "EXPR [ (1, _5, _6) (8, _2) (-1, _10) 0 ]", + "EXPR [ (-1, _9) (-1, _11) 1 ]", + "EXPR [ (1, _10, _11) (-9, _11) 0 ]", + "BRILLIG CALL func 1: PREDICATE = EXPR [ (1, _11) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Array([Expression { mul_terms: [], linear_combinations: [], q_c: 98 }, Expression { mul_terms: [], linear_combinations: [], q_c: 121 }, Expression { mul_terms: [], linear_combinations: [], q_c: 101 }])], outputs: []", - "EXPR [ (1, _5, _6) (8, _2) (-1, _13) 0 ]", - "EXPR [ (1, _9, _12) (-1, _9) (-1, _12) (-1, _14) 1 ]", - "EXPR [ (1, _13, _14) (-11, _14) 0 ]", - "EXPR [ (1, _0) (-1, _15) -1 ]", - "BLACKBOX::RANGE [(_15, 32)] []", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 })], outputs: [Simple(Witness(16))]", - "EXPR [ (1, _15, _16) (1, _17) -1 ]", - "EXPR [ (1, _15, _17) 0 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: -1 })], outputs: [Simple(Witness(18))]", - "EXPR [ (1, _15, _18) (-1, _18) (1, _19) -1 ]", - "EXPR [ (1, _15, _19) (-1, _19) 0 ]", - "EXPR [ (-1, _17) (-1, _20) 1 ]", - "EXPR [ (1, _17, _19) (-6, _17) (-1, _19) (-1, _21) 6 ]", - "EXPR [ (1, _20, _21) (4, _17) (-1, _22) -4 ]", + "EXPR [ (1, _0) (-1, _12) -1 ]", + "BLACKBOX::RANGE [(_12, 32)] []", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 })], outputs: [Simple(Witness(13))]", + "EXPR [ (1, _12, _13) (1, _14) -1 ]", + "EXPR [ (1, _12, _14) 0 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: -1 })], outputs: [Simple(Witness(15))]", + "EXPR [ (1, _12, _15) (-1, _15) (1, _16) -1 ]", + "EXPR [ (1, _12, _16) (-1, _16) 0 ]", + "EXPR [ (-1, _14) (-1, _17) 1 ]", + "EXPR [ (1, _14, _16) (-6, _14) (-1, _16) (-1, _18) 6 ]", + "EXPR [ (1, _17, _18) (4, _14) (-1, _19) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 })], outputs: [Simple(Witness(20))]", + "EXPR [ (1, _19, _20) (1, _21) -1 ]", + "EXPR [ (1, _19, _21) 0 ]", + "EXPR [ (1, _17, _18) (4, _14) (-1, _22) -5 ]", "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 })], outputs: [Simple(Witness(23))]", "EXPR [ (1, _22, _23) (1, _24) -1 ]", "EXPR [ (1, _22, _24) 0 ]", - "EXPR [ (1, _20, _21) (4, _17) (-1, _25) -5 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 })], outputs: [Simple(Witness(26))]", - "EXPR [ (1, _25, _26) (1, _27) -1 ]", - "EXPR [ (1, _25, _27) 0 ]", - "EXPR [ (1, _15) (-1, _28) 1 ]", - "EXPR [ (-1, _24, _27) (1, _27) (-1, _29) 0 ]", - "EXPR [ (1, _28, _29) (-1, _30) 0 ]", + "EXPR [ (1, _12) (-1, _25) 1 ]", + "EXPR [ (-1, _21, _24) (1, _24) (-1, _26) 0 ]", + "EXPR [ (1, _25, _26) (-1, _27) 0 ]", + "BLACKBOX::RANGE [(_27, 32)] []", + "EXPR [ (1, _17, _18) (4, _14) (-1, _28) 0 ]", + "EXPR [ (1, _21, _24) (-1, _21) (-1, _24) (-1, _29) 1 ]", + "EXPR [ (1, _28, _29) (-6, _29) 0 ]", + "EXPR [ (1, _12, _29) (2, _29) (-1, _30) 0 ]", "BLACKBOX::RANGE [(_30, 32)] []", - "EXPR [ (1, _20, _21) (4, _17) (-1, _31) 0 ]", - "EXPR [ (1, _24, _27) (-1, _24) (-1, _27) (-1, _32) 1 ]", - "EXPR [ (1, _31, _32) (-6, _32) 0 ]", - "EXPR [ (1, _15, _32) (2, _32) (-1, _33) 0 ]", - "BLACKBOX::RANGE [(_33, 32)] []", - "EXPR [ (-1, _24) (-1, _34) 1 ]", - "EXPR [ (1, _29, _30) (1, _32, _33) (-1, _35) 0 ]", - "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(24), Witness(15)), (1, Witness(34), Witness(35))], linear_combinations: [], q_c: 0 })], outputs: []", - "EXPR [ (-5, _2, _4) (5, _4) (-1, _36) 0 ]", - "EXPR [ (1, _5, _36) (4, _2) (-1, _37) -4 ]", + "EXPR [ (-1, _21) (-1, _31) 1 ]", + "EXPR [ (1, _26, _27) (1, _29, _30) (-1, _32) 0 ]", + "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(21), Witness(12)), (1, Witness(31), Witness(32))], linear_combinations: [], q_c: 0 })], outputs: []", + "EXPR [ (-5, _2, _4) (5, _4) (-1, _33) 0 ]", + "EXPR [ (1, _5, _33) (4, _2) (-1, _34) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 })], outputs: [Simple(Witness(35))]", + "EXPR [ (1, _34, _35) (1, _36) -1 ]", + "EXPR [ (1, _34, _36) 0 ]", + "EXPR [ (1, _5, _33) (4, _2) (-1, _37) -5 ]", "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 })], outputs: [Simple(Witness(38))]", "EXPR [ (1, _37, _38) (1, _39) -1 ]", "EXPR [ (1, _37, _39) 0 ]", - "EXPR [ (1, _5, _36) (4, _2) (-1, _40) -5 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 })], outputs: [Simple(Witness(41))]", - "EXPR [ (1, _40, _41) (1, _42) -1 ]", - "EXPR [ (1, _40, _42) 0 ]", - "EXPR [ (1, _0) (-1, _43) 1 ]", - "EXPR [ (-1, _39, _42) (1, _42) (-1, _44) 0 ]", - "EXPR [ (1, _43, _44) (-1, _45) 0 ]", + "EXPR [ (1, _0) (-1, _40) 1 ]", + "EXPR [ (-1, _36, _39) (1, _39) (-1, _41) 0 ]", + "EXPR [ (1, _40, _41) (-1, _42) 0 ]", + "BLACKBOX::RANGE [(_42, 32)] []", + "EXPR [ (1, _5, _33) (4, _2) (-1, _43) 0 ]", + "EXPR [ (1, _36, _39) (-1, _36) (-1, _39) (-1, _44) 1 ]", + "EXPR [ (1, _43, _44) (-6, _44) 0 ]", + "EXPR [ (1, _0, _44) (2, _44) (-1, _45) 0 ]", "BLACKBOX::RANGE [(_45, 32)] []", - "EXPR [ (1, _5, _36) (4, _2) (-1, _46) 0 ]", - "EXPR [ (1, _39, _42) (-1, _39) (-1, _42) (-1, _47) 1 ]", - "EXPR [ (1, _46, _47) (-6, _47) 0 ]", - "EXPR [ (1, _0, _47) (2, _47) (-1, _48) 0 ]", + "EXPR [ (-1, _36) (-1, _46) 1 ]", + "EXPR [ (1, _41, _42) (1, _44, _45) (-1, _47) 0 ]", + "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(36), Witness(0)), (1, Witness(46), Witness(47))], linear_combinations: [], q_c: 0 })], outputs: []", + "EXPR [ (1, _0) (-1, _48) 1 ]", "BLACKBOX::RANGE [(_48, 32)] []", - "EXPR [ (-1, _39) (-1, _49) 1 ]", - "EXPR [ (1, _44, _45) (1, _47, _48) (-1, _50) 0 ]", - "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(39), Witness(0)), (1, Witness(49), Witness(50))], linear_combinations: [], q_c: 0 })], outputs: []", - "EXPR [ (1, _0) (-1, _51) 1 ]", - "BLACKBOX::RANGE [(_51, 32)] []", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(51))], q_c: 0 })], outputs: [Simple(Witness(52))]", - "EXPR [ (1, _51, _52) (1, _53) -1 ]", - "EXPR [ (1, _51, _53) 0 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(51))], q_c: -1 })], outputs: [Simple(Witness(54))]", - "EXPR [ (1, _51, _54) (-1, _54) (1, _55) -1 ]", - "EXPR [ (1, _51, _55) (-1, _55) 0 ]", - "EXPR [ (-1, _53) (-1, _56) 1 ]", - "EXPR [ (1, _53, _55) (-6, _53) (-1, _55) (-1, _57) 6 ]", - "EXPR [ (1, _56, _57) (4, _53) (-1, _58) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(48))], q_c: 0 })], outputs: [Simple(Witness(49))]", + "EXPR [ (1, _48, _49) (1, _50) -1 ]", + "EXPR [ (1, _48, _50) 0 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(48))], q_c: -1 })], outputs: [Simple(Witness(51))]", + "EXPR [ (1, _48, _51) (-1, _51) (1, _52) -1 ]", + "EXPR [ (1, _48, _52) (-1, _52) 0 ]", + "EXPR [ (-1, _50) (-1, _53) 1 ]", + "EXPR [ (1, _50, _52) (-6, _50) (-1, _52) (-1, _54) 6 ]", + "EXPR [ (1, _53, _54) (4, _50) (-1, _55) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(55))], q_c: 0 })], outputs: [Simple(Witness(56))]", + "EXPR [ (1, _55, _56) (1, _57) -1 ]", + "EXPR [ (1, _55, _57) 0 ]", + "EXPR [ (1, _53, _54) (4, _50) (-1, _58) -5 ]", "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(58))], q_c: 0 })], outputs: [Simple(Witness(59))]", "EXPR [ (1, _58, _59) (1, _60) -1 ]", "EXPR [ (1, _58, _60) 0 ]", - "EXPR [ (1, _56, _57) (4, _53) (-1, _61) -5 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(61))], q_c: 0 })], outputs: [Simple(Witness(62))]", - "EXPR [ (1, _61, _62) (1, _63) -1 ]", - "EXPR [ (1, _61, _63) 0 ]", - "EXPR [ (1, _51) (-1, _64) 1 ]", - "EXPR [ (-1, _60, _63) (1, _63) (-1, _65) 0 ]", - "EXPR [ (1, _64, _65) (-1, _66) 0 ]", + "EXPR [ (1, _48) (-1, _61) 1 ]", + "EXPR [ (-1, _57, _60) (1, _60) (-1, _62) 0 ]", + "EXPR [ (1, _61, _62) (-1, _63) 0 ]", + "BLACKBOX::RANGE [(_63, 32)] []", + "EXPR [ (1, _53, _54) (4, _50) (-1, _64) 0 ]", + "EXPR [ (1, _57, _60) (-1, _57) (-1, _60) (-1, _65) 1 ]", + "EXPR [ (1, _64, _65) (-6, _65) 0 ]", + "EXPR [ (1, _48, _65) (2, _65) (-1, _66) 0 ]", "BLACKBOX::RANGE [(_66, 32)] []", - "EXPR [ (1, _56, _57) (4, _53) (-1, _67) 0 ]", - "EXPR [ (1, _60, _63) (-1, _60) (-1, _63) (-1, _68) 1 ]", - "EXPR [ (1, _67, _68) (-6, _68) 0 ]", - "EXPR [ (1, _51, _68) (2, _68) (-1, _69) 0 ]", - "BLACKBOX::RANGE [(_69, 32)] []", - "EXPR [ (-1, _60) (-1, _70) 1 ]", - "EXPR [ (1, _65, _66) (1, _68, _69) (-1, _71) 0 ]", - "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(60), Witness(51)), (1, Witness(70), Witness(71))], linear_combinations: [], q_c: 0 })], outputs: []", + "EXPR [ (-1, _57) (-1, _67) 1 ]", + "EXPR [ (1, _62, _63) (1, _65, _66) (-1, _68) 0 ]", + "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(57), Witness(48)), (1, Witness(67), Witness(68))], linear_combinations: [], q_c: 0 })], outputs: []", "unconstrained func 0", "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U1) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 27 }, Mov { destination: Relative(2), source: Relative(3) }, Call { location: 38 }, Call { location: 39 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 37 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 30 }, Return, Return, Call { location: 123 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 125 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(22), source: Relative(21) }, Store { destination_pointer: Relative(22), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(5) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(6) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(7) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(8) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(9) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(10) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(12) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(6) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(7) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(13) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(14) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(15) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(7) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(13) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(17) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(9) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(18) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Const { destination: Relative(3), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(4), size: 2 }), HeapArray(HeapArray { pointer: Relative(5), size: 28 }), MemoryAddress(Relative(3))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, 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: 128 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", @@ -159,7 +155,7 @@ expression: artifact "unconstrained func 3", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLRSNb2o8UuSty9Lp5Gh+uP+4Pp+/PPzff7l43D+fD8Xj4cX98ftxfDs+n+u/rZrBDqEe33QQHEYiHBEiEJEiGFIg2iaBEUCIoEZQISgQlghJBiaBEUBIoCZQESgIlgZJASaAkUBIoCZQMSgYlg5JByaBkUDIoGZQMSgalgFJAKaAUUAooBZQCSgGlgFJAUVAUFAVFQVFQFBQFRUFRUBQUNwxURxWqpwZqpCZqphYqeY48R54jz5HnyHPkOfIcea7yxFShMlArT97qScusr5T6Sqn/Sik3lVKmgtQSS60exBh0QdADQQcE7QuaF7QuaFzQtoAioAgoHhQPigfFg+JB8aB4UDwoHhQPytdb9asEZktAWALCEpC3mtt9db6/nMfR8vyv5bou4i/783i6bL6drsfjdvNrf7y2m36+7E9NL/tzvTpsN+PpqWoFfj8cRzt7275HD9OhRR2DVfwtXOSj8TlkxucyLIgXYXiQW3T8t/d+OtpLZLj3bkl81B6f4oL4MPShD26y/TQzev3pc75FB//h1sXfBi9NtV5Wzt1MvKTevuTJ9t3a5Curhm+u+xr65A9lsvv+82pH+/DpZPMz0TH1aJ3s/EzqpaGnfnJxESD07qewrAda+vQNk8XvdGYEQh+CGOMiQOmPEFUWTEHoD1DXlalwe8F9VgLV5aV3IPrJDoSVU2Dv2FVTMAtYOQV1hb4NQZjsQPm8OZChL0HihiUPkMotfnoJcysLeRbwkUKeBXwki3xYmUWzgLVZlIbbJEw/QV6SRbv6a/94OP/7HaZuF0MzNvXo2zHU9ur+vR1TO9YtYratZlvEbINpIhAPsd2lbS8jfiZIhhSI7VQDrFKBVSqwSoVWKdIrRZqlTLeUaZcy/VKhYSp0TIUmSemSlDZJ6ZOURknplJRWSemVFGZJBrilpp4aqOQF8gJ55pmEpkm6a4q0TRG+yTZH5pjs7WOWqWmiZmqhKtR8U1NHNU6CdWoaqJFKXiIvkWcGSjIcVFOH+zN5ZqJE4aL8ABvVNNmeFkaqaaGq7XDhpZo6akBdmIFqmqiZWqgKNRfV1FHF9sAwUk0DNVLJU/KUPLNTPtFP4cThCZqjwokxbWPza38+7B+OoyW+lcb19NjroP68/H7pV/oXy5fz8+P4dD2PVjPvny0r764Ops87VMWdq1PspOz616d2Q9n68n5DqDfo7vYNof1ZE6he2L1Zbf4B", + "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLRWNZ2o8UuRR39Lp5Gh+uP+4Pp+/PPzff7l43D+fD8Xj4cX98ftxfDs+n+u/rZrBDqEe33QQHEYiHBEiEJEiGFIg2iaBEUCIoEZQISgQlghJBiaBEUBIoCZQESgIlgZJASaAkUBIoCZQMSgYlg5JByaBkUDIoGZQMSgalgFJAKaAUUAooBZQCSgGlgFJAUVAUFAVFQVFQFBQFRUFRUBQUNwxURxWqpwZqpCZqphYqeY48R54jz5HnyHPkOfIcea7yxFShMlArT97qj5ZZXyn1lVL/lVJuKqVMBaklllo9iDHogqAHgg4I2hc0L2hd0LigbQFFQBFQPCgeFA+KB8WD4kHxoHhQPCgelK+36tcSmF0CwiUgXALyVnO77873l/M4Wp7/tV3XTfxlfx5Pl8230/V43G5+7Y/XdtPPl/2p6WV/rleH7WY8PVWtwO+H42i/3rbv0cN0aFHHYBV/Cxf5aHwOmfG5DAviRRge5BYd/+29n472EhnuvVsSH7XHp7ggPgx96IObbD/NjF5/+pxv0cF/uHXxt8FLU62XlXM3Ey+pty95sn23NvnKquGb676GPvlDmey+/7y1o334dLL5meiYerROdn4m9dLQUz+5uAgQevdTWNYDLX36hsnF73RmBEIfghjjIkDpjxBVFkxB6A9Q95WpcHvBfVYC1e2ldyD6yQ6ElVNg79hVUzALWDkFdYe+DUGY7ED5vDmQoW9B4oYlD5DKLX56C3MrF/Is4CMLeRbwkSzyYWUWzQLWZlEabpMw/QR5SRbt6tn+8XD+9ztMLRdDMzb16Nsx1PZq/d6OqR1riZit1GybmBWYJgLxEKsurbyMOE2QDLFSNdAqRXqlSLOU6ZYy7VKmXyo0TIWOqdAkKV2S0iYpfZLSKCmdktIqKb2SwizJALfUVKHml5qSF8gL5JlnEpom6a4p0jZF+CYrgMwx2RvGLFNToXpqoEZqomaqcRKsk6l5p6aOSl4iL5FnBkoyHFTTzPvJMxMlChflB9iopmJ1K4xU00CNVsXCSzXNUPNPlvtmoJoK1VMDNVITNVOL1bkwUqbmpJo6KnlKnpJndson+KmmGf03R9XUeFa4/NqfD/uH42iJbal/PT32PK+nl98v/Ur/Ivlyfn4cn67n0dbE+2fJ2v5dHUifd8j6O1en10nZ9a9L7Yay9eX9hlBv0N3tG0H7syZPvbB7s7X3Bw==", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 45d0957c24b..f03f0a18368 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -40,7 +40,7 @@ expression: artifact }, "bytecode": [ "func 0", - "current witness index : _71", + "current witness index : _68", "private parameters indices : [_0]", "public parameters indices : []", "return value indices : []", @@ -60,96 +60,92 @@ expression: artifact "EXPR [ (1, _7, _9) 0 ]", "BRILLIG CALL func 0: PREDICATE = EXPR [ (1, _9) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Array([Expression { mul_terms: [], linear_combinations: [], q_c: 104 }, Expression { mul_terms: [], linear_combinations: [], q_c: 105 }])], outputs: []", - "EXPR [ (1, _5, _6) (8, _2) (-1, _10) -9 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(10))], q_c: 0 })], outputs: [Simple(Witness(11))]", - "EXPR [ (1, _10, _11) (1, _12) -1 ]", - "EXPR [ (1, _10, _12) 0 ]", - "BRILLIG CALL func 1: PREDICATE = EXPR [ (-1, _9, _12) (1, _12) 0 ]", + "EXPR [ (1, _5, _6) (8, _2) (-1, _10) 0 ]", + "EXPR [ (-1, _9) (-1, _11) 1 ]", + "EXPR [ (1, _10, _11) (-9, _11) 0 ]", + "BRILLIG CALL func 1: PREDICATE = EXPR [ (1, _11) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Array([Expression { mul_terms: [], linear_combinations: [], q_c: 98 }, Expression { mul_terms: [], linear_combinations: [], q_c: 121 }, Expression { mul_terms: [], linear_combinations: [], q_c: 101 }])], outputs: []", - "EXPR [ (1, _5, _6) (8, _2) (-1, _13) 0 ]", - "EXPR [ (1, _9, _12) (-1, _9) (-1, _12) (-1, _14) 1 ]", - "EXPR [ (1, _13, _14) (-11, _14) 0 ]", - "EXPR [ (1, _0) (-1, _15) -1 ]", - "BLACKBOX::RANGE [(_15, 32)] []", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: 0 })], outputs: [Simple(Witness(16))]", - "EXPR [ (1, _15, _16) (1, _17) -1 ]", - "EXPR [ (1, _15, _17) 0 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(15))], q_c: -1 })], outputs: [Simple(Witness(18))]", - "EXPR [ (1, _15, _18) (-1, _18) (1, _19) -1 ]", - "EXPR [ (1, _15, _19) (-1, _19) 0 ]", - "EXPR [ (-1, _17) (-1, _20) 1 ]", - "EXPR [ (1, _17, _19) (-6, _17) (-1, _19) (-1, _21) 6 ]", - "EXPR [ (1, _20, _21) (4, _17) (-1, _22) -4 ]", + "EXPR [ (1, _0) (-1, _12) -1 ]", + "BLACKBOX::RANGE [(_12, 32)] []", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: 0 })], outputs: [Simple(Witness(13))]", + "EXPR [ (1, _12, _13) (1, _14) -1 ]", + "EXPR [ (1, _12, _14) 0 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(12))], q_c: -1 })], outputs: [Simple(Witness(15))]", + "EXPR [ (1, _12, _15) (-1, _15) (1, _16) -1 ]", + "EXPR [ (1, _12, _16) (-1, _16) 0 ]", + "EXPR [ (-1, _14) (-1, _17) 1 ]", + "EXPR [ (1, _14, _16) (-6, _14) (-1, _16) (-1, _18) 6 ]", + "EXPR [ (1, _17, _18) (4, _14) (-1, _19) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(19))], q_c: 0 })], outputs: [Simple(Witness(20))]", + "EXPR [ (1, _19, _20) (1, _21) -1 ]", + "EXPR [ (1, _19, _21) 0 ]", + "EXPR [ (1, _17, _18) (4, _14) (-1, _22) -5 ]", "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(22))], q_c: 0 })], outputs: [Simple(Witness(23))]", "EXPR [ (1, _22, _23) (1, _24) -1 ]", "EXPR [ (1, _22, _24) 0 ]", - "EXPR [ (1, _20, _21) (4, _17) (-1, _25) -5 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(25))], q_c: 0 })], outputs: [Simple(Witness(26))]", - "EXPR [ (1, _25, _26) (1, _27) -1 ]", - "EXPR [ (1, _25, _27) 0 ]", - "EXPR [ (1, _15) (-1, _28) 1 ]", - "EXPR [ (-1, _24, _27) (1, _27) (-1, _29) 0 ]", - "EXPR [ (1, _28, _29) (-1, _30) 0 ]", + "EXPR [ (1, _12) (-1, _25) 1 ]", + "EXPR [ (-1, _21, _24) (1, _24) (-1, _26) 0 ]", + "EXPR [ (1, _25, _26) (-1, _27) 0 ]", + "BLACKBOX::RANGE [(_27, 32)] []", + "EXPR [ (1, _17, _18) (4, _14) (-1, _28) 0 ]", + "EXPR [ (1, _21, _24) (-1, _21) (-1, _24) (-1, _29) 1 ]", + "EXPR [ (1, _28, _29) (-6, _29) 0 ]", + "EXPR [ (1, _12, _29) (2, _29) (-1, _30) 0 ]", "BLACKBOX::RANGE [(_30, 32)] []", - "EXPR [ (1, _20, _21) (4, _17) (-1, _31) 0 ]", - "EXPR [ (1, _24, _27) (-1, _24) (-1, _27) (-1, _32) 1 ]", - "EXPR [ (1, _31, _32) (-6, _32) 0 ]", - "EXPR [ (1, _15, _32) (2, _32) (-1, _33) 0 ]", - "BLACKBOX::RANGE [(_33, 32)] []", - "EXPR [ (-1, _24) (-1, _34) 1 ]", - "EXPR [ (1, _29, _30) (1, _32, _33) (-1, _35) 0 ]", - "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(24), Witness(15)), (1, Witness(34), Witness(35))], linear_combinations: [], q_c: 0 })], outputs: []", - "EXPR [ (-5, _2, _4) (5, _4) (-1, _36) 0 ]", - "EXPR [ (1, _5, _36) (4, _2) (-1, _37) -4 ]", + "EXPR [ (-1, _21) (-1, _31) 1 ]", + "EXPR [ (1, _26, _27) (1, _29, _30) (-1, _32) 0 ]", + "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(21), Witness(12)), (1, Witness(31), Witness(32))], linear_combinations: [], q_c: 0 })], outputs: []", + "EXPR [ (-5, _2, _4) (5, _4) (-1, _33) 0 ]", + "EXPR [ (1, _5, _33) (4, _2) (-1, _34) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(34))], q_c: 0 })], outputs: [Simple(Witness(35))]", + "EXPR [ (1, _34, _35) (1, _36) -1 ]", + "EXPR [ (1, _34, _36) 0 ]", + "EXPR [ (1, _5, _33) (4, _2) (-1, _37) -5 ]", "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(37))], q_c: 0 })], outputs: [Simple(Witness(38))]", "EXPR [ (1, _37, _38) (1, _39) -1 ]", "EXPR [ (1, _37, _39) 0 ]", - "EXPR [ (1, _5, _36) (4, _2) (-1, _40) -5 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(40))], q_c: 0 })], outputs: [Simple(Witness(41))]", - "EXPR [ (1, _40, _41) (1, _42) -1 ]", - "EXPR [ (1, _40, _42) 0 ]", - "EXPR [ (1, _0) (-1, _43) 1 ]", - "EXPR [ (-1, _39, _42) (1, _42) (-1, _44) 0 ]", - "EXPR [ (1, _43, _44) (-1, _45) 0 ]", + "EXPR [ (1, _0) (-1, _40) 1 ]", + "EXPR [ (-1, _36, _39) (1, _39) (-1, _41) 0 ]", + "EXPR [ (1, _40, _41) (-1, _42) 0 ]", + "BLACKBOX::RANGE [(_42, 32)] []", + "EXPR [ (1, _5, _33) (4, _2) (-1, _43) 0 ]", + "EXPR [ (1, _36, _39) (-1, _36) (-1, _39) (-1, _44) 1 ]", + "EXPR [ (1, _43, _44) (-6, _44) 0 ]", + "EXPR [ (1, _0, _44) (2, _44) (-1, _45) 0 ]", "BLACKBOX::RANGE [(_45, 32)] []", - "EXPR [ (1, _5, _36) (4, _2) (-1, _46) 0 ]", - "EXPR [ (1, _39, _42) (-1, _39) (-1, _42) (-1, _47) 1 ]", - "EXPR [ (1, _46, _47) (-6, _47) 0 ]", - "EXPR [ (1, _0, _47) (2, _47) (-1, _48) 0 ]", + "EXPR [ (-1, _36) (-1, _46) 1 ]", + "EXPR [ (1, _41, _42) (1, _44, _45) (-1, _47) 0 ]", + "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(36), Witness(0)), (1, Witness(46), Witness(47))], linear_combinations: [], q_c: 0 })], outputs: []", + "EXPR [ (1, _0) (-1, _48) 1 ]", "BLACKBOX::RANGE [(_48, 32)] []", - "EXPR [ (-1, _39) (-1, _49) 1 ]", - "EXPR [ (1, _44, _45) (1, _47, _48) (-1, _50) 0 ]", - "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(39), Witness(0)), (1, Witness(49), Witness(50))], linear_combinations: [], q_c: 0 })], outputs: []", - "EXPR [ (1, _0) (-1, _51) 1 ]", - "BLACKBOX::RANGE [(_51, 32)] []", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(51))], q_c: 0 })], outputs: [Simple(Witness(52))]", - "EXPR [ (1, _51, _52) (1, _53) -1 ]", - "EXPR [ (1, _51, _53) 0 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(51))], q_c: -1 })], outputs: [Simple(Witness(54))]", - "EXPR [ (1, _51, _54) (-1, _54) (1, _55) -1 ]", - "EXPR [ (1, _51, _55) (-1, _55) 0 ]", - "EXPR [ (-1, _53) (-1, _56) 1 ]", - "EXPR [ (1, _53, _55) (-6, _53) (-1, _55) (-1, _57) 6 ]", - "EXPR [ (1, _56, _57) (4, _53) (-1, _58) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(48))], q_c: 0 })], outputs: [Simple(Witness(49))]", + "EXPR [ (1, _48, _49) (1, _50) -1 ]", + "EXPR [ (1, _48, _50) 0 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(48))], q_c: -1 })], outputs: [Simple(Witness(51))]", + "EXPR [ (1, _48, _51) (-1, _51) (1, _52) -1 ]", + "EXPR [ (1, _48, _52) (-1, _52) 0 ]", + "EXPR [ (-1, _50) (-1, _53) 1 ]", + "EXPR [ (1, _50, _52) (-6, _50) (-1, _52) (-1, _54) 6 ]", + "EXPR [ (1, _53, _54) (4, _50) (-1, _55) -4 ]", + "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(55))], q_c: 0 })], outputs: [Simple(Witness(56))]", + "EXPR [ (1, _55, _56) (1, _57) -1 ]", + "EXPR [ (1, _55, _57) 0 ]", + "EXPR [ (1, _53, _54) (4, _50) (-1, _58) -5 ]", "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(58))], q_c: 0 })], outputs: [Simple(Witness(59))]", "EXPR [ (1, _58, _59) (1, _60) -1 ]", "EXPR [ (1, _58, _60) 0 ]", - "EXPR [ (1, _56, _57) (4, _53) (-1, _61) -5 ]", - "BRILLIG CALL func 3: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(61))], q_c: 0 })], outputs: [Simple(Witness(62))]", - "EXPR [ (1, _61, _62) (1, _63) -1 ]", - "EXPR [ (1, _61, _63) 0 ]", - "EXPR [ (1, _51) (-1, _64) 1 ]", - "EXPR [ (-1, _60, _63) (1, _63) (-1, _65) 0 ]", - "EXPR [ (1, _64, _65) (-1, _66) 0 ]", + "EXPR [ (1, _48) (-1, _61) 1 ]", + "EXPR [ (-1, _57, _60) (1, _60) (-1, _62) 0 ]", + "EXPR [ (1, _61, _62) (-1, _63) 0 ]", + "BLACKBOX::RANGE [(_63, 32)] []", + "EXPR [ (1, _53, _54) (4, _50) (-1, _64) 0 ]", + "EXPR [ (1, _57, _60) (-1, _57) (-1, _60) (-1, _65) 1 ]", + "EXPR [ (1, _64, _65) (-6, _65) 0 ]", + "EXPR [ (1, _48, _65) (2, _65) (-1, _66) 0 ]", "BLACKBOX::RANGE [(_66, 32)] []", - "EXPR [ (1, _56, _57) (4, _53) (-1, _67) 0 ]", - "EXPR [ (1, _60, _63) (-1, _60) (-1, _63) (-1, _68) 1 ]", - "EXPR [ (1, _67, _68) (-6, _68) 0 ]", - "EXPR [ (1, _51, _68) (2, _68) (-1, _69) 0 ]", - "BLACKBOX::RANGE [(_69, 32)] []", - "EXPR [ (-1, _60) (-1, _70) 1 ]", - "EXPR [ (1, _65, _66) (1, _68, _69) (-1, _71) 0 ]", - "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(60), Witness(51)), (1, Witness(70), Witness(71))], linear_combinations: [], q_c: 0 })], outputs: []", + "EXPR [ (-1, _57) (-1, _67) 1 ]", + "EXPR [ (1, _62, _63) (1, _65, _66) (-1, _68) 0 ]", + "BRILLIG CALL func 2: inputs: [Single(Expression { mul_terms: [], linear_combinations: [], q_c: 1 }), Single(Expression { mul_terms: [(1, Witness(57), Witness(48)), (1, Witness(67), Witness(68))], linear_combinations: [], q_c: 0 })], outputs: []", "unconstrained func 0", "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U1) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U8) }, Cast { destination: Direct(32838), source: Direct(32838), bit_size: Integer(U8) }, Mov { destination: Relative(1), source: Direct(32836) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 2 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 27 }, Mov { destination: Relative(2), source: Relative(3) }, Call { location: 38 }, Call { location: 39 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32839 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 37 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 30 }, Return, Return, Call { location: 123 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 125 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(21) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(22), source: Relative(21) }, Store { destination_pointer: Relative(22), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(5) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(6) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(7) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(8) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(9) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(10) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(12) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(6) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(7) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(13) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(14) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(15) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(16) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(7) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(13) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(17) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(4) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(9) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(18) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Const { destination: Relative(3), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(4), size: 2 }), HeapArray(HeapArray { pointer: Relative(5), size: 28 }), MemoryAddress(Relative(3))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, 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: 128 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", @@ -159,7 +155,7 @@ expression: artifact "unconstrained func 3", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLRSNb2o8UuSty9Lp5Gh+uP+4Pp+/PPzff7l43D+fD8Xj4cX98ftxfDs+n+u/rZrBDqEe33QQHEYiHBEiEJEiGFIg2iaBEUCIoEZQISgQlghJBiaBEUBIoCZQESgIlgZJASaAkUBIoCZQMSgYlg5JByaBkUDIoGZQMSgalgFJAKaAUUAooBZQCSgGlgFJAUVAUFAVFQVFQFBQFRUFRUBQUNwxURxWqpwZqpCZqphYqeY48R54jz5HnyHPkOfIcea7yxFShMlArT97qScusr5T6Sqn/Sik3lVKmgtQSS60exBh0QdADQQcE7QuaF7QuaFzQtoAioAgoHhQPigfFg+JB8aB4UDwoHhQPytdb9asEZktAWALCEpC3mtt9db6/nMfR8vyv5bou4i/783i6bL6drsfjdvNrf7y2m36+7E9NL/tzvTpsN+PpqWoFfj8cRzt7275HD9OhRR2DVfwtXOSj8TlkxucyLIgXYXiQW3T8t/d+OtpLZLj3bkl81B6f4oL4MPShD26y/TQzev3pc75FB//h1sXfBi9NtV5Wzt1MvKTevuTJ9t3a5Curhm+u+xr65A9lsvv+82pH+/DpZPMz0TH1aJ3s/EzqpaGnfnJxESD07qewrAda+vQNk8XvdGYEQh+CGOMiQOmPEFUWTEHoD1DXlalwe8F9VgLV5aV3IPrJDoSVU2Dv2FVTMAtYOQV1hb4NQZjsQPm8OZChL0HihiUPkMotfnoJcysLeRbwkUKeBXwki3xYmUWzgLVZlIbbJEw/QV6SRbv6a/94OP/7HaZuF0MzNvXo2zHU9ur+vR1TO9YtYratZlvEbINpIhAPsd2lbS8jfiZIhhSI7VQDrFKBVSqwSoVWKdIrRZqlTLeUaZcy/VKhYSp0TIUmSemSlDZJ6ZOURknplJRWSemVFGZJBrilpp4aqOQF8gJ55pmEpkm6a4q0TRG+yTZH5pjs7WOWqWmiZmqhKtR8U1NHNU6CdWoaqJFKXiIvkWcGSjIcVFOH+zN5ZqJE4aL8ABvVNNmeFkaqaaGq7XDhpZo6akBdmIFqmqiZWqgKNRfV1FHF9sAwUk0DNVLJU/KUPLNTPtFP4cThCZqjwokxbWPza38+7B+OoyW+lcb19NjroP68/H7pV/oXy5fz8+P4dD2PVjPvny0r764Ops87VMWdq1PspOz616d2Q9n68n5DqDfo7vYNof1ZE6he2L1Zbf4B", + "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLRWNZ2o8UuRR39Lp5Gh+uP+4Pp+/PPzff7l43D+fD8Xj4cX98ftxfDs+n+u/rZrBDqEe33QQHEYiHBEiEJEiGFIg2iaBEUCIoEZQISgQlghJBiaBEUBIoCZQESgIlgZJASaAkUBIoCZQMSgYlg5JByaBkUDIoGZQMSgalgFJAKaAUUAooBZQCSgGlgFJAUVAUFAVFQVFQFBQFRUFRUBQUNwxURxWqpwZqpCZqphYqeY48R54jz5HnyHPkOfIcea7yxFShMlArT97qj5ZZXyn1lVL/lVJuKqVMBaklllo9iDHogqAHgg4I2hc0L2hd0LigbQFFQBFQPCgeFA+KB8WD4kHxoHhQPCgelK+36tcSmF0CwiUgXALyVnO77873l/M4Wp7/tV3XTfxlfx5Pl8230/V43G5+7Y/XdtPPl/2p6WV/rleH7WY8PVWtwO+H42i/3rbv0cN0aFHHYBV/Cxf5aHwOmfG5DAviRRge5BYd/+29n472EhnuvVsSH7XHp7ggPgx96IObbD/NjF5/+pxv0cF/uHXxt8FLU62XlXM3Ey+pty95sn23NvnKquGb676GPvlDmey+/7y1o334dLL5meiYerROdn4m9dLQUz+5uAgQevdTWNYDLX36hsnF73RmBEIfghjjIkDpjxBVFkxB6A9Q95WpcHvBfVYC1e2ldyD6yQ6ElVNg79hVUzALWDkFdYe+DUGY7ED5vDmQoW9B4oYlD5DKLX56C3MrF/Is4CMLeRbwkSzyYWUWzQLWZlEabpMw/QR5SRbt6tn+8XD+9ztMLRdDMzb16Nsx1PZq/d6OqR1riZit1GybmBWYJgLxEKsurbyMOE2QDLFSNdAqRXqlSLOU6ZYy7VKmXyo0TIWOqdAkKV2S0iYpfZLSKCmdktIqKb2SwizJALfUVKHml5qSF8gL5JlnEpom6a4p0jZF+CYrgMwx2RvGLFNToXpqoEZqomaqcRKsk6l5p6aOSl4iL5FnBkoyHFTTzPvJMxMlChflB9iopmJ1K4xU00CNVsXCSzXNUPNPlvtmoJoK1VMDNVITNVOL1bkwUqbmpJo6KnlKnpJndson+KmmGf03R9XUeFa4/NqfD/uH42iJbal/PT32PK+nl98v/Ur/Ivlyfn4cn67n0dbE+2fJ2v5dHUifd8j6O1en10nZ9a9L7Yay9eX9hlBv0N3tG0H7syZPvbB7s7X3Bw==", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index a8828780391..b996caf37a0 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -50,9 +50,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32857 }, 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(32856), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32856) }, Call { location: 13 }, Call { location: 35 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32857 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U1), 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(U8), value: 34 }, Const { destination: Direct(32840), bit_size: Integer(U8), value: 44 }, Const { destination: Direct(32841), bit_size: Integer(U8), value: 50 }, Const { destination: Direct(32842), bit_size: Integer(U8), value: 51 }, Const { destination: Direct(32843), bit_size: Integer(U8), value: 58 }, Const { destination: Direct(32844), bit_size: Integer(U8), value: 100 }, Const { destination: Direct(32845), bit_size: Integer(U8), value: 101 }, Const { destination: Direct(32846), bit_size: Integer(U8), value: 103 }, Const { destination: Direct(32847), bit_size: Integer(U8), value: 104 }, Const { destination: Direct(32848), bit_size: Integer(U8), value: 105 }, Const { destination: Direct(32849), bit_size: Integer(U8), value: 107 }, Const { destination: Direct(32850), bit_size: Integer(U8), value: 110 }, Const { destination: Direct(32851), bit_size: Integer(U8), value: 114 }, Const { destination: Direct(32852), bit_size: Integer(U8), value: 115 }, Const { destination: Direct(32853), bit_size: Integer(U8), value: 116 }, Const { destination: Direct(32854), bit_size: Integer(U8), value: 123 }, Const { destination: Direct(32855), bit_size: Integer(U8), value: 125 }, Return, Call { location: 175 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 181 }, Mov { destination: Direct(0), source: Relative(0) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 46 }, Call { location: 390 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 393 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 38 }, 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(32854) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32849) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, 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: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32852) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32840) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32847) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32842) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 393 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 149 }, Call { location: 440 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 157 }, Call { location: 443 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 393 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 170 }, Call { location: 440 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 180 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, JumpIf { condition: Relative(3), location: 222 }, Jump { location: 187 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(3), location: 218 }, Jump { location: 190 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Direct(32835), rhs: Direct(32837) }, JumpIf { condition: Relative(3), location: 218 }, 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: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, Mov { destination: Relative(6), source: Relative(5) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(6) }, Mov { destination: Direct(32773), source: Relative(8) }, Call { location: 446 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(5), size: Relative(4) } }, Mov { destination: Relative(1), source: Relative(5) }, Jump { location: 220 }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 224 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 224 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 108 }, JumpIf { condition: Relative(1), location: 315 }, Jump { location: 228 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 237 }, Jump { location: 231 }, Const { destination: Relative(1), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 236 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 389 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Relative(6), source: Relative(5) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Direct(32845) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32842) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(2), size: 3 }), HeapArray(HeapArray { pointer: Relative(3), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 389 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(4), source: Direct(32847) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Direct(32848) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(4) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32841) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(3), size: 2 }), HeapArray(HeapArray { pointer: Relative(4), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 389 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 409 }, Jump { location: 400 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 411 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 411 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 436 }, Jump { location: 414 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 428 }, Jump { location: 417 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 421 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 426 }, Call { location: 443 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 434 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 432 }, Call { location: 443 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 434 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 438 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 438 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 456 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 449 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32857 }, 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(32856), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32856), source: Direct(32856), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32856) }, Call { location: 13 }, Call { location: 35 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32857 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U1), 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(U8), value: 34 }, Const { destination: Direct(32840), bit_size: Integer(U8), value: 44 }, Const { destination: Direct(32841), bit_size: Integer(U8), value: 50 }, Const { destination: Direct(32842), bit_size: Integer(U8), value: 51 }, Const { destination: Direct(32843), bit_size: Integer(U8), value: 58 }, Const { destination: Direct(32844), bit_size: Integer(U8), value: 100 }, Const { destination: Direct(32845), bit_size: Integer(U8), value: 101 }, Const { destination: Direct(32846), bit_size: Integer(U8), value: 103 }, Const { destination: Direct(32847), bit_size: Integer(U8), value: 104 }, Const { destination: Direct(32848), bit_size: Integer(U8), value: 105 }, Const { destination: Direct(32849), bit_size: Integer(U8), value: 107 }, Const { destination: Direct(32850), bit_size: Integer(U8), value: 110 }, Const { destination: Direct(32851), bit_size: Integer(U8), value: 114 }, Const { destination: Direct(32852), bit_size: Integer(U8), value: 115 }, Const { destination: Direct(32853), bit_size: Integer(U8), value: 116 }, Const { destination: Direct(32854), bit_size: Integer(U8), value: 123 }, Const { destination: Direct(32855), bit_size: Integer(U8), value: 125 }, Return, Call { location: 175 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(3), source: Direct(0) }, Mov { destination: Relative(4), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(2) }, Call { location: 181 }, Mov { destination: Direct(0), source: Relative(0) }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 46 }, Call { location: 387 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(5), source: Direct(0) }, Mov { destination: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(4) }, Call { location: 390 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(6) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 38 }, 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(32854) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32849) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, 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: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32852) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32850) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32846) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32845) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32840) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32848) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32844) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32853) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32847) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32839) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32843) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32842) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 390 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 149 }, Call { location: 437 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 157 }, Call { location: 440 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 390 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 170 }, Call { location: 437 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 180 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, JumpIf { condition: Relative(3), location: 224 }, Jump { location: 187 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, JumpIf { condition: Relative(6), location: 220 }, Jump { location: 190 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(6), source: Direct(1) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(7) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Mov { destination: Relative(8), source: Relative(7) }, Store { destination_pointer: Relative(8), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U1, lhs: Direct(32835), rhs: Direct(32837) }, JumpIf { condition: Relative(7), location: 218 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(9), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, Mov { destination: Relative(10), source: Relative(9) }, IndirectConst { destination_pointer: Relative(10), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(11) }, Mov { destination: Direct(32772), source: Relative(10) }, Mov { destination: Direct(32773), source: Relative(12) }, Call { location: 443 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(9), size: Relative(8) } }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 222 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 222 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 226 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 226 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U8), value: 108 }, JumpIf { condition: Relative(1), location: 312 }, Jump { location: 230 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 234 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Relative(6), source: Relative(5) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Direct(32845) }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32842) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(2), size: 3 }), HeapArray(HeapArray { pointer: Relative(3), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 386 }, Mov { destination: Relative(1), source: Direct(1) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(2) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(4), source: Direct(32847) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Direct(32848) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(4) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Direct(32854) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32849) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32844) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32852) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32848) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32840) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32845) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32850) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32846) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32853) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32847) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32839) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32843) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32841) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Direct(32855) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Direct(32837)), HeapArray(HeapArray { pointer: Relative(3), size: 2 }), HeapArray(HeapArray { pointer: Relative(4), size: 28 }), MemoryAddress(Direct(32835))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 386 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 175 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 406 }, Jump { location: 397 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 408 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 408 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 433 }, Jump { location: 411 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 425 }, Jump { location: 414 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 418 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 423 }, Call { location: 440 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 431 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 429 }, Call { location: 440 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 431 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 435 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 435 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 453 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 446 }, Return]" ], - "debug_symbols": "tdjNThtLEEDhd/GaxfRfVTevEkWRAyayZBnkwJWuEO9+u1x1fGFhhGyxSR1C+rM97hlP/Lq63/x++fNru394/Lu6/fG6+n3Y7nbbP792j3fr5+3jfv7t62qxP4qsbtPNqqiP7mMcR118JB95dZvnKD6qj+ZjKmUO9dF9jONoi4/kI/uYisxRfTQf4kN9dB/jOGTxkXxkH66IK+KKuCKuiCviirqirqgr6oq6oq6oK+qKuqKudFe6K92V7kp3pbvSXemudFe6K8OV4cpwZbgyXBmuDFeGK8OV4UpalpgpZo5ZYtaYLabE1Jg9ZngpvBReCi+Fl8JL4aXwUngpvBReDi+Hl8PL4eXwcng5vBxeDi+HV8Ir4ZXwSnhlemqzxZxet6kxe8zh0zb5caaYOeb0UrKoRCOEUKITI8J2vYedPdkiEyYXi0o0QgiTq0UnRoSdCR6JyEQhTLZXb+eEhxBKdGJE2NnhkQiT7WjYOXIM2+1pWEwnLzNsH3skIhOFqEQjhDg58/lkOz62sy2ybW2PRGSiEJVohBBKdAI5ISfkhJyQE3JCTsgJ2TZvLhY9wralRyYKwT+2relhTrXoxIiwbemRiEwUohKNEAK5Ildk25lZLRKRiUJUohFCKNGJESHIgizIgizIgizIgizIgqzIiqzIiqzIiqzIiqzIityRO3JH7sgduSN35I7ckTvyQB7IA3kgD+SBPJAH8kAeIZdlIRKRiUJUohFCKNEJ5IR8PC+6RSYKYeCwEEKJTowIu/p7JCIThZhPtWSLRgihRCdGhH0OeCQiE4VALsgFuSAX5IJckStyRa7IFbkiV+SKXJErckNuyA25ITfkhtyQG3JDbsiCLMiCLMiCLMiCLMiCLMiKrMiKrMiKrMiKrMiKrMgduSN35I7cke3UK8VCCI2wk6hUu101sFmkCNvGRSwqoUQnRoTtVQ9bpRaZKEQlGmFOtxgRx515DHP629vNivvuX8+HzcZuu9/diM/b86f1YbN/Xt3uX3a7m9U/693L8R/9fVrvj/N5fZi/nR+Sm/39nBN82O42Vm83/69ezi+1D6vj2ppPi9uXV48Sq0e/YHUTVo8LVtceq+eN7rnl9fzyPhKPnstpfc4f1rfvW69VY7325dz6T15+sts5f/2tXHD45u3+aX09t35c+frT8o3AtUdw3hjG+nnXd8kRlH5any5av5zWnz350rVbMMk3Ate+BfODPdbPD+sLDuH8mGO9tEuuIQtvQT3/Fub0yQHg8ql6Wl7Llx8+l9PVV84+fLnq4T9bPu8yOXzL2Qt4vnYHZvlG4Es78NNDeC0w/wfDaaxn38Ry7YWwpG8Erj2NZeE0lHTJaSiVQyj1klsBGVyJdTl7JS2f7KLWeQJtXAZUPk1b+3gEfs6f1nfbw4dvWN9MOmzXv3eb+PHhZX/37rfP/z7xG76hfTo83m3uXw4bk959TTvvE+t89Nrkp31ZN39M2m5SX+zHeZ/5o4zlpoz8882ezH8=", + "debug_symbols": "tdjNThtLEEDhd/GaxfRfVTevEkWRAyayZBnkwJWuEO9+u1x1fGFhhGyxSR2H9Gc87vFM/Lq63/x++fNru394/Lu6/fG6+n3Y7nbbP792j3fr5+3jfv7t62qxP4qsbtPNqqiP7mMcR118JB95dZvnKD6qj+ZjKmUO9dF9jONoi4/kI/uYisxRfTQf4kN9dB/jOGTxkXxkH66IK+KKuCKuiCviirqirqgr6oq6oq6oK+qKuqKudFe6K92V7kp3pbvSXemudFe6K8OV4cpwZbgyXBmuDFeGK8OV4UpalpgpZo5ZYtaYLabE1Jg9ZngpvBReCi+Fl8JL4aXwUngpvBReDi+Hl8PL4eXwcng5vBxeDi+HV8Ir4ZXwSnhlemqzxZxet6kxe8zh0zb5caaYOeb0UrKoRCOEUKITI8J2vYedPdkiEyYXi0o0QgiTq0UnRoSdCR6JyEQhTLZXb+eEhxBKdGJE2NnhkQiT7WjYOXIM2+1pWEwnLzNsH3skIhOFqEQjhDg58/fJdnxsZ1tk29oeichEISrRCCGU6ARyQk7ICTkhJ+SEnJATsm3WPN+vbLvSIxGZKISB1aIRQijRiRFh+9MjEZkoBHJFrsi2RbNadGJE2Bb1SEQmClGJRgiB3JAbsiALsiALsiALsiALsiALsiIrsiIrsiIrsiIrsiIrckfuyB25I3fkjtyRO3JH7sgDeSAP5IE8kAfyQB7IA3mEXJaFSEQmClGJRgihhMndYkQcT5BjGDgsClGJRgihRCdGhF0GPOw+IFtkohCVaIQQSnRiRNip54FckAtyQS7IBbkgF+SCXJErckWuyBW5IlfkilyRK3JDbsgNuSE35IbckBtyQ27IgizIgizIgizIgizIgizIiqzIiqzIiqzIiqzIiqzIHbkj26lXikUhaoSdRKVaGNgsuke1bVzEblgTUYlGCKGErVKLEWF71SMRmTCnWwihhDn97e1mxV32r+fDZmM32e9uu+fN+NP6sNk/r273L7vdzeqf9e7l+I/+Pq33x/m8PsyfzkviZn8/5wQftruN1dvN/6uX80vt0nRcW/Npcfvy6lFi9egXrG7C6nHB6tpj9bytPbe8nl/eR+LZczmtz/nD+vZ967VqrNe+nFv/yctPdvPmr7+VCw7fvLk/ra/n1o8rX39avhG49gjO28BYP+/xLjmC0k/r00Xrl9P6sydfunYLJvlG4Nq3YF69Y/28Il9wCOe1jPXSLvkMWXgL6vm3MKdPDgAfn6qn5bV8+elzOX36ytmnL1c9/WfL560kh285+wGer92BWb4R+NIO/PQQXgvM/6ZwGuvZN7Fc+0FY0jcC157GsnAaSrrkNJTKIZR6ya2ADD6JdTn7SVo+2UWt8wu0cRlQuZq29vEI/JyP1nfbw4fvU99MOmzXv3ebePjwsr9799Pnf5/4Cd/HPh0e7zb3L4eNSe++lJ33iXUev9rKT/tqbj5M2m5SX+zhvCn9UbrelD5+vtkv8x8=", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap index a121db9ff0e..4212beda329 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_0.snap @@ -50,9 +50,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32837) }, Call { location: 13 }, Call { location: 16 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 376 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, Const { destination: Relative(6), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(3), location: 59 }, Jump { location: 24 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(3), location: 55 }, Jump { location: 27 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(7) }, JumpIf { condition: Relative(3), location: 55 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, Mov { destination: Relative(8), source: Relative(5) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(9) }, Mov { destination: Direct(32772), source: Relative(8) }, Mov { destination: Direct(32773), source: Relative(10) }, Call { location: 382 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(5), size: Relative(4) } }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 57 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 61 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 61 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(3), location: 169 }, Jump { location: 82 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 91 }, Jump { location: 85 }, Const { destination: Relative(3), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(5), location: 90 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Jump { location: 243 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(25) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(25) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(25), source: Relative(3) }, Store { destination_pointer: Relative(25), source: Relative(9) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(11) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(13) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(15) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(19) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(20) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(21) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(4) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(24) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(23) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(3), size: 3 }), HeapArray(HeapArray { pointer: Relative(20), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 243 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(4) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(25), source: Relative(5) }, Store { destination_pointer: Relative(25), source: Relative(9) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(11) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(13) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(15) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(19) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(20) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(21) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(4) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(23) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(5), size: 2 }), HeapArray(HeapArray { pointer: Relative(20), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 243 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32836), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 247 }, Call { location: 393 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 25 }, Mov { destination: Relative(25), source: Direct(0) }, Mov { destination: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 396 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(26) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(25) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(25) }, Store { destination_pointer: Relative(26), source: Relative(9) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(15) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(17) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(19) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(5) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(4) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(23) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 21 }, Mov { destination: Relative(21), source: Direct(0) }, Mov { destination: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 396 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(22) }, Load { destination: Relative(3), source_pointer: Relative(20) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 350 }, Call { location: 443 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 358 }, Call { location: 446 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 21 }, Mov { destination: Relative(21), source: Direct(0) }, Mov { destination: Relative(22), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 396 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(22) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 371 }, Call { location: 443 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 381 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 392 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 385 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 376 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 412 }, Jump { location: 403 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 414 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 414 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 439 }, Jump { location: 417 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 431 }, Jump { location: 420 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 424 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 429 }, Call { location: 446 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 437 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 435 }, Call { location: 446 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 437 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 441 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 441 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32837), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32837) }, Call { location: 13 }, Call { location: 16 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Integer(U32), value: 1 }, Return, Call { location: 373 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 8 }, Const { destination: Relative(5), bit_size: Field, value: 9 }, Const { destination: Relative(6), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(3), location: 61 }, Jump { location: 24 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 57 }, Jump { location: 27 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(9), source: Direct(1) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(10) }, IndirectConst { destination_pointer: Relative(9), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Mov { destination: Relative(11), source: Relative(10) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Const { destination: Relative(8), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U1, lhs: Relative(6), rhs: Relative(7) }, JumpIf { condition: Relative(10), location: 55 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(12), source: Direct(1) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(13) }, Mov { destination: Relative(13), source: Relative(12) }, IndirectConst { destination_pointer: Relative(13), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(14) }, Mov { destination: Direct(32772), source: Relative(13) }, Mov { destination: Direct(32773), source: Relative(15) }, Call { location: 379 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(8) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(12), size: Relative(11) } }, Mov { destination: Relative(3), source: Relative(8) }, Jump { location: 59 }, Mov { destination: Relative(3), source: Relative(5) }, Jump { location: 59 }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 63 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 63 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(4) }, Const { destination: Relative(4), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(3), location: 166 }, Jump { location: 84 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(3), location: 88 }, Const { destination: Relative(25), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(25) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(3), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(25) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(25) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(25), source: Relative(3) }, Store { destination_pointer: Relative(25), source: Relative(9) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(11) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(13) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(15) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(19) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(20) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(21) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(4) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(24) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(23) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(3), size: 3 }), HeapArray(HeapArray { pointer: Relative(20), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 240 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(4) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(25), source: Relative(5) }, Store { destination_pointer: Relative(25), source: Relative(9) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(11) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(13) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(15) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(17) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(8) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(19) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(20) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(21) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(12) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(18) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(16) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(4) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(10) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(14) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(22) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(25), rhs: Direct(2) }, Store { destination_pointer: Relative(25), source: Relative(23) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), HeapArray(HeapArray { pointer: Relative(5), size: 2 }), HeapArray(HeapArray { pointer: Relative(20), size: 28 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 240 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32836), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 244 }, Call { location: 390 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 25 }, Mov { destination: Relative(25), source: Direct(0) }, Mov { destination: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 393 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(26) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(20), source: Direct(1) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(25) }, IndirectConst { destination_pointer: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Mov { destination: Relative(26), source: Relative(25) }, Store { destination_pointer: Relative(26), source: Relative(9) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(11) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(2) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(15) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(12) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(18) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(21) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(17) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(19) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(5) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(8) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(13) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(16) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(4) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(10) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(14) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(23) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(3)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, Const { destination: Relative(3), bit_size: Integer(U32), value: 21 }, Mov { destination: Relative(21), source: Direct(0) }, Mov { destination: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 393 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(2), source: Relative(22) }, Load { destination: Relative(3), source_pointer: Relative(20) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 347 }, Call { location: 440 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(2)), HeapArray(HeapArray { pointer: Relative(3), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 355 }, Call { location: 443 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 21 }, Mov { destination: Relative(21), source: Direct(0) }, Mov { destination: Relative(22), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 393 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(1), source: Relative(22) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 368 }, Call { location: 440 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(7)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(6))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 378 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 389 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 382 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 373 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32835) }, Const { destination: Relative(4), bit_size: Field, value: 4 }, Const { destination: Relative(5), bit_size: Field, value: 5 }, Const { destination: Relative(6), bit_size: Field, value: 6 }, JumpIf { condition: Relative(3), location: 409 }, Jump { location: 400 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, Not { destination: Relative(7), source: Relative(3), bit_size: U1 }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(3), source: Relative(7), bit_size: Field }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(8), rhs: Relative(5) }, BinaryFieldOp { destination: Relative(8), op: Mul, lhs: Relative(3), rhs: Relative(6) }, BinaryFieldOp { destination: Relative(3), op: Add, lhs: Relative(7), rhs: Relative(8) }, Mov { destination: Relative(2), source: Relative(3) }, Jump { location: 411 }, Mov { destination: Relative(2), source: Relative(4) }, Jump { location: 411 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(4) }, JumpIf { condition: Relative(7), location: 436 }, Jump { location: 414 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(5) }, JumpIf { condition: Relative(7), location: 428 }, Jump { location: 417 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 421 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Const { destination: Relative(2), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, JumpIf { condition: Relative(6), location: 426 }, Call { location: 443 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 434 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32836) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 432 }, Call { location: 443 }, Mov { destination: Relative(4), source: Relative(2) }, Jump { location: 434 }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 438 }, Mov { destination: Relative(3), source: Relative(1) }, Jump { location: 438 }, Mov { destination: Relative(1), source: Relative(3) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tdjNThtZEEDhd+m1F11V95dXiRAyYCJLlkEOjDRCvHtu9b2HhEWjyJY3U4dx6jM03Xbj9+lxd//2825/fHr+Nd38eJ/uT/vDYf/z7vD8sH3dPx/b/32fZv+P5OlGN5OG6cbayH2UPuoybO5D+tA+rI++Z3G6iW2kPnIfpY+6jDD3IX1oH9ZH6KMroSuhK6EroSuxK7ErsSuxK7ErqT2WNlPRPmIfqY/cR+mjLqO2hdyG9mF9hD5iH6mP3Efpoy5D5nlMGVPHtDEbJbNHJBKRiULUETITQihhBLIgC7IgC7IgK7IiK7IiK7IiK7IiK7IiG7IhG7IhG7IhG7IhG7IhB+SAHJADckAOyAE5IAfkgByRI3JEjsgROSJH5IgckSNyQk7ICTkhJ+TksngkIhMOtmtU8kwIoYQRgYhEIjLh32r0qCPKTAihhBGBiEQiMoFckCtyRa7IFbkiV+SKXJErch2yzjMhhBJGBCISichEIZAFWZAFWZAFWZAFWZAFWZAVWZEVWZEVWZEVWZEVWZEN2ZAN2ZAN2ZAN2ZANebn0kr8zzIQQDmaPQEQiEQ4Wj0LUEcsVt4QQShjRZBWPSCQiE4WoI/yK6yGEEkYgJ+SEnJATckLOyBk5I2fkjJyRM3JGzsgZuSAX5IJckAtyQS7IBbkgF+SKXJErckWuyBW5IlfkilyHbPNMCKGEEYGIRCIyUQhkQRZkQRZkQRZkQRZkQRZkRVZkRVZkRVZkRVZkRVZkQzZkQzZkQ/ZLT9UjES4vd1SFqCP80ushhBJGuJw8IpGITBSijvBrsIcQLmcPI1wuHpFIRCZcrh51xHINLiGEEkYEosnmB8GvwR6ZKEQd4ddgDyGU8LtRPxp+DS7hZ68Fv+30h5b7zzDCzx9LHnmEnxs9hFDCCN/KHpFIRCbKiOVeuXgoYYQ75eNjM3Ezfvd62u38Xvyvu/N2z/6yPe2Or9PN8e1w2Ez/bQ9vyz/69bI9LvN1e2qPtnuH3fGxzQY+7Q87r4/Nn+15fdXPvmU36Ody/Lot69vtGhnr7bw/Zz9W9lM8Yz/M/OhBVp8/rO9nfvqcP7eD/fOz+7U3Dl5ae/Z00bN/s91etjl2c1l79rK+X6qM/ar2ua/6Zb9ebz+HzI9f5rX9dL39djcw9ttb9Oq5ZxceAAlXBP7pEHxz8VeOQF09gb7ZjontesZ2KGO7/em8evQvPf10viJw6dEX4QJuf2SecQTbJwif+2FtXy89//wV/mrApYew/UnHNSzzOYcwlc99OWt//txfff+0S09CkysCl/4K0sxbeJJ4xiFMgRehFM55HUmVX2Ge138F37wPxMI3EOt5QOA6jPHrEbhtX20f9qcvH7l+uHTab+8Pu/Hl09vx4a9HX/9/4RE+sn05PT/sHt9OO5f+fG7bbid/WNGNVb31jw39y5w2VsS/FP+yvcRbjbcf/s38Bg==", + "debug_symbols": "tdjdTttaEEDhd8l1Ljwz+294laqqAoQqUhRQCkc6Qrx793h70XJhVCXiprNSOl+osROT1839/vbl54/D6eHx1+bm2+vm9nw4Hg8/fxwf73bPh8dT/9vXzRR/SN3c6HajaXNjfdQx2hg+D5vGkDF0DBtj7Fne3OQ+yhh1jDaGzyNNY8gYOoaNkcYYShpKGkoaShpKHkoeSh5KHkoeSumPynbT0hh5jDJGHaObtQ+fh09jyBg6ho2RxshjlDHqGEPxocg0LbM7MkUoYUQiMlGISjTCl5CJQBZkQRZkQRZkQRZkQVZkRVZkRVZkRVZkRVZkRTZkQzZkQzZkQzZkQzZkQ07ICTkhJ+SEnJATckJOyAk5I2fkjJyRM3JGzsgZOSNn5IJckEvIEmFEIgLUiEo0wpeoEyGEEkYkIr7VHFGISjTCl2gTIYQSRiQCuSE35IbckB3ZkR3ZkR3ZkR3ZkR3ZF1mniRBCCSMSkYlCVKIRyIIsyIIsyIIsyIIsyIIsyIqsyIqsyIqsyIqsyIqsyIZsyIZsyIZsyPOlVyIq0ZaYr7gaIYQSRgTYIjJRiEo0wpeYr7g5uqwSoYQRichEISrRCF8irrgRyAW5IBfkglyQC3JBLsgVuSJX5IpckStyRa7IFbkiN+SG3JAbckNuyA25ITfkhuzIjuzIjuzIjuzIjuzIvsg2TYQQShiRiEwUohKNQBZkQRZkQRZkQRZkQRZkQVZkRVZkRVZkRVZkRVZkRTZkQ45LTzXCiJDnG6hMFKISjfAl4hocEXKJUMKIRGSiEJVoRMg17twmIuQWoYQRiQjZIwpRiUb4EvM1OIcQce8YByGuwRGJyEQhKtEIXyKuQYujEdfgHHH2Woq7zPjSfLspS8T5YyUiEZVohC8R58aI2KoRShiRiEyE0yJ8ifmeeY5w2tvbdsO994/n834ft95/3Yz3W/Sn3Xl/et7cnF6Ox+3mv93xZf5Hv552p3k+7879q/3eYX+677ODD4fjPupt+2d7Wl+Ns2/eTfq+nD9uy/p2vxCW9X5yX7Kfnf2SL9jvP1i+fVl9/rS+X/nf1/q+neyfnz2uveXglbVnL1c9+yfb/bWZYze1tWdv6/vNZdl3tfd91Q/7/nX7NVX++21a2y9ft9/f8pf9/j68eu7ZlQdA0hcC/3QIPrn4nSPgqyfQJ9u5sO0XbKe2bPdfkVeP/rWnn05fCFx79EW4gPtvkhccwf4xwft+WtvXa8+/eIX/MuDaQ9h/b+MalumSQ1ja+75ctD+976++f9q1J6HJFwLX/gjKxFt4kXzBISyJF6GSLnkdKc6PsE7rP4JP3gdy4xvIfhmQuA5z/ngEvvdHu7vD+cMnrG8hnQ+72+N+efjwcrr766vP/z/xFT6hfTo/3u3vX877kP58TNvvPb9Z9a01/x6fDc4PbWu1xUOJhz5tzfX7W3wzvwE=", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 1db2c1067b9..2a32174cbfa 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -50,9 +50,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 477 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, Const { destination: Relative(7), bit_size: Field, value: 8 }, Const { destination: Relative(8), bit_size: Field, value: 9 }, Const { destination: Relative(9), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 59 }, Jump { location: 25 }, JumpIf { condition: Relative(6), location: 55 }, Jump { location: 27 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(3) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 55 }, 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: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, Mov { destination: Relative(6), source: Relative(5) }, IndirectConst { destination_pointer: Relative(6), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(7) }, Mov { destination: Direct(32772), source: Relative(6) }, Mov { destination: Direct(32773), source: Relative(8) }, Call { location: 483 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(5), size: Relative(4) } }, Mov { destination: Relative(11), source: Relative(8) }, Jump { location: 57 }, Mov { destination: Relative(2), source: Relative(11) }, Jump { location: 61 }, Mov { destination: Relative(2), source: Relative(7) }, Jump { location: 61 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(26), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(28), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(11), location: 169 }, Jump { location: 82 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 91 }, Jump { location: 85 }, Const { destination: Relative(8), bit_size: Field, value: 11 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 90 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 243 }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(29) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(30), source: Relative(29) }, Store { destination_pointer: Relative(30), source: Relative(2) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(8) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(25) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(29), source: Relative(8) }, Store { destination_pointer: Relative(29), source: Relative(13) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(15) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(17) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(19) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(21) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(23) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(25) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(7) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(27) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(8), size: 3 }), HeapArray(HeapArray { pointer: Relative(24), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 243 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Relative(29), source: Relative(11) }, Store { destination_pointer: Relative(29), source: Relative(13) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(15) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(17) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(19) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(21) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(23) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(25) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(7) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(26) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(27) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(11), size: 2 }), HeapArray(HeapArray { pointer: Relative(24), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 243 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 247 }, Call { location: 494 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Const { destination: Relative(24), bit_size: Field, value: 4 }, Const { destination: Relative(29), bit_size: Field, value: 5 }, Const { destination: Relative(30), bit_size: Field, value: 6 }, JumpIf { condition: Relative(11), location: 262 }, Jump { location: 253 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(31), source: Relative(11), bit_size: U1 }, Cast { destination: Relative(32), source: Relative(11), bit_size: Field }, Cast { destination: Relative(11), source: Relative(31), bit_size: Field }, BinaryFieldOp { destination: Relative(31), op: Mul, lhs: Relative(32), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(32), op: Mul, lhs: Relative(11), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(31), rhs: Relative(32) }, Mov { destination: Relative(2), source: Relative(11) }, Jump { location: 264 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 264 }, BinaryFieldOp { destination: Relative(31), op: Equals, lhs: Relative(2), rhs: Relative(24) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(31), location: 289 }, Jump { location: 268 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(33), location: 281 }, Jump { location: 271 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(33), location: 275 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(32) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 279 }, Call { location: 497 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 287 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 285 }, Call { location: 497 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 287 }, Mov { destination: Relative(11), source: Relative(31) }, Jump { location: 291 }, Mov { destination: Relative(11), source: Relative(8) }, Jump { location: 291 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(31), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(33), source: Direct(1) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(34) }, IndirectConst { destination_pointer: Relative(33), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, Mov { destination: Relative(35), source: Relative(34) }, Store { destination_pointer: Relative(35), source: Relative(13) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(15) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(8) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(19) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(22) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(20) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(22) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(21) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(23) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(31) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(20) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(7) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(28) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(26) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(27) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(11)), HeapArray(HeapArray { pointer: Relative(7), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, JumpIf { condition: Relative(4), location: 384 }, Jump { location: 376 }, Not { destination: Relative(4), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(7), source: Relative(6), bit_size: Field }, Cast { destination: Relative(6), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Mul, lhs: Relative(7), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(6), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(6), op: Add, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(6) }, Jump { location: 386 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 386 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(24) }, JumpIf { condition: Relative(6), location: 410 }, Jump { location: 389 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(7), location: 402 }, Jump { location: 392 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(7), location: 396 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(32) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 400 }, Call { location: 497 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 408 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 406 }, Call { location: 497 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 408 }, Mov { destination: Relative(4), source: Relative(6) }, Jump { location: 412 }, Mov { destination: Relative(4), source: Relative(1) }, Jump { location: 412 }, Load { destination: Relative(6), source_pointer: Relative(33) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 418 }, Call { location: 500 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(4)), HeapArray(HeapArray { pointer: Relative(6), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 426 }, Call { location: 497 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(1), location: 438 }, Jump { location: 429 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Not { destination: Relative(3), source: Relative(1), bit_size: U1 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Cast { destination: Relative(1), source: Relative(3), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(6), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(6), op: Mul, lhs: Relative(1), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Add, lhs: Relative(3), rhs: Relative(6) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 440 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 440 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(24) }, JumpIf { condition: Relative(3), location: 464 }, Jump { location: 443 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(6), location: 456 }, Jump { location: 446 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(5), location: 450 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(32) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 454 }, Call { location: 497 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 462 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 460 }, Call { location: 497 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 462 }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 466 }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 466 }, Load { destination: Relative(2), source_pointer: Relative(33) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 472 }, Call { location: 500 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 482 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 493 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 486 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 474 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, Const { destination: Relative(7), bit_size: Field, value: 8 }, Const { destination: Relative(8), bit_size: Field, value: 9 }, Const { destination: Relative(9), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(10), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 61 }, Jump { location: 25 }, JumpIf { condition: Relative(6), location: 57 }, Jump { location: 27 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 33 }, Mov { destination: Relative(13), source: Direct(1) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(14) }, IndirectConst { destination_pointer: Relative(13), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Mov { destination: Relative(15), source: Relative(14) }, Store { destination_pointer: Relative(15), source: Relative(12) }, Const { destination: Relative(12), bit_size: Field, value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U1, lhs: Relative(9), rhs: Relative(10) }, JumpIf { condition: Relative(14), location: 55 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, Mov { destination: Relative(16), source: Direct(1) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(17) }, Mov { destination: Relative(17), source: Relative(16) }, IndirectConst { destination_pointer: Relative(17), bit_size: Integer(U64), value: 11660857942269032329 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 1 }, Mov { destination: Direct(32771), source: Relative(18) }, Mov { destination: Direct(32772), source: Relative(17) }, Mov { destination: Direct(32773), source: Relative(19) }, Call { location: 480 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(12) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(17), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(16), size: Relative(15) } }, Mov { destination: Relative(11), source: Relative(12) }, Jump { location: 59 }, Mov { destination: Relative(11), source: Relative(8) }, Jump { location: 59 }, Mov { destination: Relative(2), source: Relative(11) }, Jump { location: 63 }, Mov { destination: Relative(2), source: Relative(7) }, Jump { location: 63 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(7) }, Const { destination: Relative(7), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 105 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 123 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 34 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 58 }, Const { destination: Relative(19), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(20), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(21), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(22), bit_size: Integer(U8), value: 103 }, Const { destination: Relative(23), bit_size: Integer(U8), value: 44 }, Const { destination: Relative(24), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(25), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(26), bit_size: Integer(U8), value: 50 }, Const { destination: Relative(27), bit_size: Integer(U8), value: 125 }, Const { destination: Relative(28), bit_size: Integer(U8), value: 51 }, JumpIf { condition: Relative(11), location: 166 }, Jump { location: 84 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(2), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 88 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Const { destination: Relative(2), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 121 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(29) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(30), source: Relative(29) }, Store { destination_pointer: Relative(30), source: Relative(2) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(8) }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(30), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(25) }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(29), source: Relative(8) }, Store { destination_pointer: Relative(29), source: Relative(13) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(15) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(17) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(19) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(21) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(23) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(25) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(7) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(28) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(27) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(8), size: 3 }), HeapArray(HeapArray { pointer: Relative(24), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 3 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 240 }, Mov { destination: Relative(2), source: Direct(1) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(2), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(11), source: Relative(7) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Mov { destination: Relative(8), source: Direct(1) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(11) }, IndirectConst { destination_pointer: Relative(8), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Mov { destination: Relative(29), source: Relative(11) }, Store { destination_pointer: Relative(29), source: Relative(13) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(15) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(17) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(19) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(21) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(12) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(23) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(25) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(16) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(20) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(7) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(14) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(18) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(26) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(29), rhs: Direct(2) }, Store { destination_pointer: Relative(29), source: Relative(27) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), HeapArray(HeapArray { pointer: Relative(11), size: 2 }), HeapArray(HeapArray { pointer: Relative(24), size: 28 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Array { value_types: [Simple(Integer(U8))], size: 2 }, Array { value_types: [Simple(Integer(U8))], size: 28 }, Simple(Integer(U1))] }, Jump { location: 240 }, BinaryIntOp { destination: Relative(8), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 244 }, Call { location: 491 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Const { destination: Relative(24), bit_size: Field, value: 4 }, Const { destination: Relative(29), bit_size: Field, value: 5 }, Const { destination: Relative(30), bit_size: Field, value: 6 }, JumpIf { condition: Relative(11), location: 259 }, Jump { location: 250 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(31), source: Relative(11), bit_size: U1 }, Cast { destination: Relative(32), source: Relative(11), bit_size: Field }, Cast { destination: Relative(11), source: Relative(31), bit_size: Field }, BinaryFieldOp { destination: Relative(31), op: Mul, lhs: Relative(32), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(32), op: Mul, lhs: Relative(11), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(31), rhs: Relative(32) }, Mov { destination: Relative(2), source: Relative(11) }, Jump { location: 261 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 261 }, BinaryFieldOp { destination: Relative(31), op: Equals, lhs: Relative(2), rhs: Relative(24) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 2 }, JumpIf { condition: Relative(31), location: 286 }, Jump { location: 265 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(33), location: 278 }, Jump { location: 268 }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(33), location: 272 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(32) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 276 }, Call { location: 494 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 284 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, JumpIf { condition: Relative(33), location: 282 }, Call { location: 494 }, Mov { destination: Relative(31), source: Relative(2) }, Jump { location: 284 }, Mov { destination: Relative(11), source: Relative(31) }, Jump { location: 288 }, Mov { destination: Relative(11), source: Relative(8) }, Jump { location: 288 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(31), bit_size: Integer(U8), value: 119 }, Mov { destination: Relative(33), source: Direct(1) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 38 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(34) }, IndirectConst { destination_pointer: Relative(33), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, Mov { destination: Relative(35), source: Relative(34) }, Store { destination_pointer: Relative(35), source: Relative(13) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(15) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(8) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(19) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(22) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(16) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(20) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(22) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(25) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(21) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(23) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(31) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(12) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(17) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(20) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(7) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(14) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(28) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(26) }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(35), rhs: Direct(2) }, Store { destination_pointer: Relative(35), source: Relative(27) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(11)), HeapArray(HeapArray { pointer: Relative(7), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, JumpIf { condition: Relative(4), location: 381 }, Jump { location: 373 }, Not { destination: Relative(4), source: Relative(6), bit_size: U1 }, Cast { destination: Relative(7), source: Relative(6), bit_size: Field }, Cast { destination: Relative(6), source: Relative(4), bit_size: Field }, BinaryFieldOp { destination: Relative(4), op: Mul, lhs: Relative(7), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(7), op: Mul, lhs: Relative(6), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(6), op: Add, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(6) }, Jump { location: 383 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 383 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(24) }, JumpIf { condition: Relative(6), location: 407 }, Jump { location: 386 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(7), location: 399 }, Jump { location: 389 }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(7), location: 393 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(32) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 397 }, Call { location: 494 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 405 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(7), location: 403 }, Call { location: 494 }, Mov { destination: Relative(6), source: Relative(2) }, Jump { location: 405 }, Mov { destination: Relative(4), source: Relative(6) }, Jump { location: 409 }, Mov { destination: Relative(4), source: Relative(1) }, Jump { location: 409 }, Load { destination: Relative(6), source_pointer: Relative(33) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 415 }, Call { location: 497 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(4)), HeapArray(HeapArray { pointer: Relative(6), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, JumpIf { condition: Relative(6), location: 423 }, Call { location: 494 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, JumpIf { condition: Relative(1), location: 435 }, Jump { location: 426 }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Not { destination: Relative(3), source: Relative(1), bit_size: U1 }, Cast { destination: Relative(6), source: Relative(1), bit_size: Field }, Cast { destination: Relative(1), source: Relative(3), bit_size: Field }, BinaryFieldOp { destination: Relative(3), op: Mul, lhs: Relative(6), rhs: Relative(29) }, BinaryFieldOp { destination: Relative(6), op: Mul, lhs: Relative(1), rhs: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Add, lhs: Relative(3), rhs: Relative(6) }, Mov { destination: Relative(2), source: Relative(1) }, Jump { location: 437 }, Mov { destination: Relative(2), source: Relative(24) }, Jump { location: 437 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(2), rhs: Relative(24) }, JumpIf { condition: Relative(3), location: 461 }, Jump { location: 440 }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(2), rhs: Relative(29) }, JumpIf { condition: Relative(6), location: 453 }, Jump { location: 443 }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(2), rhs: Relative(30) }, JumpIf { condition: Relative(5), location: 447 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(32) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 451 }, Call { location: 494 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 459 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(6), location: 457 }, Call { location: 494 }, Mov { destination: Relative(3), source: Relative(2) }, Jump { location: 459 }, Mov { destination: Relative(1), source: Relative(3) }, Jump { location: 463 }, Mov { destination: Relative(1), source: Relative(4) }, Jump { location: 463 }, Load { destination: Relative(2), source_pointer: Relative(33) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 469 }, Call { location: 497 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(33), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(33), rhs: Direct(2) }, ForeignCall { function: \"print\", destinations: [], destination_value_types: [], inputs: [MemoryAddress(Relative(10)), MemoryAddress(Relative(1)), HeapArray(HeapArray { pointer: Relative(2), size: 37 }), MemoryAddress(Relative(9))], input_value_types: [Simple(Integer(U1)), Simple(Integer(U32)), Array { value_types: [Simple(Integer(U8))], size: 37 }, Simple(Integer(U1))] }, 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: 479 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 490 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 483 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "tZnLbts8EEbfxessxLnwklcpisJNncKA4QRu8gM/grx7OaJO0ixkBDay6XdUZ44kckTT9svm1+7n8+8f++P9w5/N7beXzc/T/nDY//5xeLjbPu0fjv1/XzZT/JN8cys3m5RHlM2t9ahzSD/yHnVEm0OnEWmEjNARNqI7S488ooyoI9ocNo1II2SEjrARw2LDYsNiw2LD4sPiw+LD4sPiw5L7a/VmU2WEj8gjyog6os3RekHrISN0hI3wEXlEGVFHtDnSNC2ZlpQldcmuSjHUkwMZKEAF2gJpAhIggAKYE+aEOWFOmBNmwSyYBbNgFsyCWTALZsEsmBWzYlbMilkxK2bFrJgVs2I2zIbZMBtmw2yYDbNhNsyG2TE7ZsfsmB2zY3bMjtkxO+aMOWPOmDPmjDmHWQMyUIAQxjNaJiABAihggAMZKEBcagloC9QJSIAAChjgQAYKgLlibpgb5oa5YW6YG+aGuWFumNtilmkCEiCAAgY4kIECVABzwpwwJ8wJc8KcMCfMCXPCnDALZsEsmAWzYBbMglkwC2bBrJgVs2JWzIpZMStmxayY50evr44yP3ozJCCELcAABzLQhZI6xEMkEmALRM+LBtQFop8HCKAAfxz9LPNbVAYKUBeI7pX5/UsABWyB6EOJu4g+HKCAAQ5koAAVaAM0+nBAAgRQwAAHMlCACmBOmBPmhDlhTpgT5oQ5YU6YE2bBLJgFs2AWzIJZMAtmwSyYFbNiVsyKWTErZsWsmBWzYjbMhtkwG2bDbJgNs2E2zIbZMTtmx+yYHbNjdsyO2TE75ow5Y86YM+aMOWPOmDPmjDljLpgL5vnZaQEK5HlTp7FO6xTQFojeH6CAAQ5EVQooQAXaAItOVwlQwABfIHpWPUABAxzIQAEq0BaIntUckIAwz5tJBQxwIMwtoHtsii3ntEA0lMVdRPsMyEABKtAWiGaxuK9olgECKBAeDShABdoCMckWdxGTPKACbYGY5AEJEECBfss2b5c94PX1ZsOe/8fTabeLLf8/HwL6R4PH7Wl3fNrcHp8Ph5vNf9vD8/xHfx63xzmftqf+ah+h3fFXzy683x92Qa8379XTemms8nOtyVuxf6xO69Uay/Rc3teQtfozZ0+xx5nr+wZurV7X63NMz1yfrV1y/d64/uwX1NvE0Ftavf+8Xl8Y/VLeqk0/fXbRt8nLa2evV539THV/C2bspro6dmcmv7a0CJq8T77IR0H6QkGJh3GMQJ3WBPXr6iUzgX2ntDqEfu0I5C8UfGoIzjRBYwRavWD98Ez16tMvZ8rzxOOfk18k+Mz6c1bQKsM3rS7AcmYF9MoVeLtMYIyhu18wBcYN9O9WVs9/bQdK+ULBp1pYr5xDna6cw7OCK+ewf8n19jZsqxegV86B2hcKrl2H+rcOLMVpumQIc32rX90JaL1yLTor+MxadFbwmT62dGUfnxVc28d5epuE9Qu4tg3Nv1Cw3sff+9H2bn/68DPBa5hO++3Pw245vH8+3v3z6tP/j7zCzwyPp4e73a/n0y5M77819A8p36zPoDX9Hl9ux2EpN1YlDlMc9h2ftfz9NS7mLw==", + "debug_symbols": "tdndThs7FEDhd8l1Lrx/7LF5laqqUppWkaKAUjjSUcW713s8C8rFRCgRN2evHPCXZMYZpvBn82P//fnXt8Pp58Pvzd2XP5vv58PxePj17fhwv3s6PJz6//2zSfEfyZs73W6kjDFt7ryPOg/tj3IfdYw2D0tjyBg6ho3hY3Rz6qOMMY1Rx2jz8DSGjKFj2Bg+xlB8KD4UH4oPJQ8lDyUPJQ8lD6X0R3W7qT5GHqOMMY3RzdZHm0dLY8gYOoaN4WPkMcoY0xhDaUORlJbZHYkjm5QwwolMFGIiKtGWkEQgC7IgC7IgC7IgC7IgK7IiK7IiK7IiK7IiK7IiG7IhG7IhG7IhG7IhG7IhO7IjO7IjO7IjO7IjO7IjZ+SMnJEzckbOyBk5I2fkjFyQC3IJ2SKMcCLA+EiWiahEW2JKhBBKGOFEvNQpohATUYm2RE2EEEoY4QRyRa7IFbkiN+SG3JAbckNuyA25ITfktsiaEiGEEkY4kYlCTEQlkAVZkAVZkAVZkAVZkAVZkBVZkRVZkRVZkRVZkRVZkQ3ZkA3ZkA3ZkOePXo2YiLrE/IlrEUIoYUQHVXrEh0g1QpaIPa8WkYlKtCViP4/gm2M/6/wTyQgnMhFO/JyK3TtH7N4RQsT3xLuIfThH7MMRQihhhBOZKMREILdFtpQIIZQwwolMFGIiKoEsyIIsyIIsyIIsyIIsyIKsyIqsyIqsyIqsyIqsyIpsyIZsyIZsyIZsyIZsyIbsyI7syI7syI7syI7syI6ckTNyRs7IGTkjZ+SMnJEzckEuyAW5IBfkglyQC3JBnj87LW62EmHzPZzFddpSRCHaErH3RwihRKySCCcyUYhwNO7lEiGEEvE9OW70EiGEEkY4kYlC9HdsJaISIc/3jokQQomQW0R3PEVMS8SGcombzUQY4UQmChGr4n3FZhnRlojNMiIci3AiE2WJOMke7yJO8ohMFGIiKtGWiJM8or9ln++ONeLlZbvhFv/b03m/jzv8f+75+78EHnfn/elpc3d6Ph63m/92x+f5m34/7k7zfNqd+1f7EdqffvTZwZ+H4z7qZfu2Oq0vjav8vNb1dXF+v1rWV1tcpufl/UKxtv7Cs0vc48zr+13a2npbX1/i9Mzri7drXn9uvP6Sr1jfP0scPll9/2V9/cTRn6bX1W4ffna115NX1p693vTsF1b3n7Mcu1RXj92Fk1+bLEDTt5Ov+h6QTwSm+DCOI1DTGlA/b70WTqBOqydQ8q1HoHwi8KFDcGETNI5Aq1dcP3Jh9eqnXy8sL4mPf5F8FfCR689FoFUOX1q9AOuFK2CuvILcrgOcY5hzvuIUOG+g/w5l9flv3YE6fSLwoS1sN55DSzeew4vAjeew/ybr9cewr74Au/EcmH8icOt1qP9qgUuxpGsOYamv61fvBKzeeC26CHzkWnQR+Mg+drlxH18Ebt3HJb2ehPUXcOs29PyJwPo+/tof7e4P53d/FXgJ6XzYfT/ul4c/n0/3/3z16f9HvsJfFR7PD/f7H8/nfUhvf1ro/8b54jVtvaWv8RvseDj51qcWDyUe9jfnzb6+xIv5Cw==", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index 652ca425d73..612bbb7338d 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -43,11 +43,11 @@ expression: artifact "BRILLIG CALL func 0: PREDICATE = EXPR [ (1, _1) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 20 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 25 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 21 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 26 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "nZHNqsMgEIXfZdYu1MT0Jq9SSjDJtAhigtULJfjuHfND20WgdDNHnfnmCGeGAbt4a427jndozjN03lhrbq0dex3M6Oh1Bp6LKKERDIRapVrltMrfKjVJSgx2ug0eMcNv68hk0h5dgMZFaxn8axuXofuk3aJBe+pyBugGUlp4NRbzKbEXzY9RVasNrvgLV1/zp2LDBRdHuDzGy7rceMXVD/aFqDa+kNUHf6Gb7o3/zEfQIAO51GKplFWZsoE3urOYp/Ke6Podomt4THtnj33yY49D9JgN3rKnepacSXVJ+RNP", + "debug_symbols": "nZHdisMgEIXfZa69UBPtJq9SSjDJtAhigtWFJfjuO+aHtheBZW/mqDPfHOEsMGKfHp319+kJ7XWBPljn7KNz02CinTy9LsBLETW0goFQm+hNLpt8bdKQ5MzgoLsYEAv8to5MZhPQR2h9co7Bt3FpHXrOxq8aTaAuZ4B+JKWFd+uwnDJ70fwcVY3aYc1fuPozf6l2XHBxhstzvG7qnVdc/cO+EnrnK6k/+BvdzGDDZz6CBhnItVZrpazqXAyCNb3DMlX2JD8cEF3jz3x0jtjnMA04poDF4C17qlcpmNS3XD7xCw==", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_0.snap index 652ca425d73..612bbb7338d 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_0.snap @@ -43,11 +43,11 @@ expression: artifact "BRILLIG CALL func 0: PREDICATE = EXPR [ (1, _1) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 20 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 25 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 21 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 26 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "nZHNqsMgEIXfZdYu1MT0Jq9SSjDJtAhigtULJfjuHfND20WgdDNHnfnmCGeGAbt4a427jndozjN03lhrbq0dex3M6Oh1Bp6LKKERDIRapVrltMrfKjVJSgx2ug0eMcNv68hk0h5dgMZFaxn8axuXofuk3aJBe+pyBugGUlp4NRbzKbEXzY9RVasNrvgLV1/zp2LDBRdHuDzGy7rceMXVD/aFqDa+kNUHf6Gb7o3/zEfQIAO51GKplFWZsoE3urOYp/Ke6Podomt4THtnj33yY49D9JgN3rKnepacSXVJ+RNP", + "debug_symbols": "nZHdisMgEIXfZa69UBPtJq9SSjDJtAhigtWFJfjuO+aHtheBZW/mqDPfHOEsMGKfHp319+kJ7XWBPljn7KNz02CinTy9LsBLETW0goFQm+hNLpt8bdKQ5MzgoLsYEAv8to5MZhPQR2h9co7Bt3FpHXrOxq8aTaAuZ4B+JKWFd+uwnDJ70fwcVY3aYc1fuPozf6l2XHBxhstzvG7qnVdc/cO+EnrnK6k/+BvdzGDDZz6CBhnItVZrpazqXAyCNb3DMlX2JD8cEF3jz3x0jtjnMA04poDF4C17qlcpmNS3XD7xCw==", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index 652ca425d73..612bbb7338d 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -43,11 +43,11 @@ expression: artifact "BRILLIG CALL func 0: PREDICATE = EXPR [ (1, _1) 0 ]", "inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(3))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 20 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 25 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 21 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(3), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(4), location: 20 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, 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: 26 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]", "unconstrained func 1", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "nZHNqsMgEIXfZdYu1MT0Jq9SSjDJtAhigtULJfjuHfND20WgdDNHnfnmCGeGAbt4a427jndozjN03lhrbq0dex3M6Oh1Bp6LKKERDIRapVrltMrfKjVJSgx2ug0eMcNv68hk0h5dgMZFaxn8axuXofuk3aJBe+pyBugGUlp4NRbzKbEXzY9RVasNrvgLV1/zp2LDBRdHuDzGy7rceMXVD/aFqDa+kNUHf6Gb7o3/zEfQIAO51GKplFWZsoE3urOYp/Ke6Podomt4THtnj33yY49D9JgN3rKnepacSXVJ+RNP", + "debug_symbols": "nZHdisMgEIXfZa69UBPtJq9SSjDJtAhigtWFJfjuO+aHtheBZW/mqDPfHOEsMGKfHp319+kJ7XWBPljn7KNz02CinTy9LsBLETW0goFQm+hNLpt8bdKQ5MzgoLsYEAv8to5MZhPQR2h9co7Bt3FpHXrOxq8aTaAuZ4B+JKWFd+uwnDJ70fwcVY3aYc1fuPozf6l2XHBxhstzvG7qnVdc/cO+EnrnK6k/+BvdzGDDZz6CBhnItVZrpazqXAyCNb3DMlX2JD8cEF3jz3x0jtjnMA04poDF4C17qlcpmNS3XD7xCw==", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index b2bc743d93c..1f5c31ed217 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -38,9 +38,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, JumpIf { condition: Relative(2), location: 19 }, Jump { location: 18 }, Return, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 25 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 26 }, JumpIf { condition: Relative(2), location: 18 }, Jump { location: 25 }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 25 }, 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: 31 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "dZDBCoQgEIbfZc4ezLagXiUirKYQxMR0YQnffTVrtw5d/BzH7x+YDUbs3dwJNS0r1M0GvRFSirmTy8CtWFR43YDGI6ugZgQYTcgSWEKe8ArwnsBpd9YgRvkSF4ZoblBZqJWTksCbS7d/WjVXOy03oUsJoBoDQ+AkJMabJ3+bPqt5Vh5yzsqfXtz97NkvquLwS0pvfhsqPghzW5CPSUbwXuJRTk4Nl6796LNzLlibZcDRGYxJly2Hs2EFyWnr47Qv", + "debug_symbols": "dZDdCoQgEEbfZa69UKPYepWIsJpCEBPThSV899V+duuiG4/jeL6BWWHAzk+t1OO8QFWv0FmplJxaNffCyVnH1xVoOtgLKk6AlRs43cF28B1ZRAgETrt1FjHJl7g4xAiL2kGlvVIE3kL57dNihN7ohI1dSgD1EBkDR6kw3QL52/RZzVhxyBkvfnp+99mzn5f54ReU3vwmVqKX9ragkJKsFJ3Coxy97i9d9zFn51ywsXOPg7eYki5bjmfNC5KxJqRpXw==", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_0.snap index b2bc743d93c..1f5c31ed217 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_0.snap @@ -38,9 +38,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, JumpIf { condition: Relative(2), location: 19 }, Jump { location: 18 }, Return, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 25 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 26 }, JumpIf { condition: Relative(2), location: 18 }, Jump { location: 25 }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 25 }, 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: 31 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "dZDBCoQgEIbfZc4ezLagXiUirKYQxMR0YQnffTVrtw5d/BzH7x+YDUbs3dwJNS0r1M0GvRFSirmTy8CtWFR43YDGI6ugZgQYTcgSWEKe8ArwnsBpd9YgRvkSF4ZoblBZqJWTksCbS7d/WjVXOy03oUsJoBoDQ+AkJMabJ3+bPqt5Vh5yzsqfXtz97NkvquLwS0pvfhsqPghzW5CPSUbwXuJRTk4Nl6796LNzLlibZcDRGYxJly2Hs2EFyWnr47Qv", + "debug_symbols": "dZDdCoQgEEbfZa69UKPYepWIsJpCEBPThSV899V+duuiG4/jeL6BWWHAzk+t1OO8QFWv0FmplJxaNffCyVnH1xVoOtgLKk6AlRs43cF28B1ZRAgETrt1FjHJl7g4xAiL2kGlvVIE3kL57dNihN7ohI1dSgD1EBkDR6kw3QL52/RZzVhxyBkvfnp+99mzn5f54ReU3vwmVqKX9ragkJKsFJ3Coxy97i9d9zFn51ywsXOPg7eYki5bjmfNC5KxJqRpXw==", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index b2bc743d93c..1f5c31ed217 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_5435/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -38,9 +38,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 }), Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(1))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 25 }, JumpIf { condition: Relative(2), location: 19 }, Jump { location: 18 }, Return, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 25 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 30 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 2 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(3), offset_address: Relative(4) }, Cast { destination: Direct(32837), source: Direct(32837), bit_size: Integer(U1) }, Mov { destination: Relative(1), source: Direct(32836) }, Mov { destination: Relative(2), source: Direct(32837) }, Call { location: 14 }, Call { location: 15 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32838 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 26 }, JumpIf { condition: Relative(2), location: 18 }, Jump { location: 25 }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 24 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Jump { location: 25 }, 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: 31 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "dZDBCoQgEIbfZc4ezLagXiUirKYQxMR0YQnffTVrtw5d/BzH7x+YDUbs3dwJNS0r1M0GvRFSirmTy8CtWFR43YDGI6ugZgQYTcgSWEKe8ArwnsBpd9YgRvkSF4ZoblBZqJWTksCbS7d/WjVXOy03oUsJoBoDQ+AkJMabJ3+bPqt5Vh5yzsqfXtz97NkvquLwS0pvfhsqPghzW5CPSUbwXuJRTk4Nl6796LNzLlibZcDRGYxJly2Hs2EFyWnr47Qv", + "debug_symbols": "dZDdCoQgEEbfZa69UKPYepWIsJpCEBPThSV899V+duuiG4/jeL6BWWHAzk+t1OO8QFWv0FmplJxaNffCyVnH1xVoOtgLKk6AlRs43cF28B1ZRAgETrt1FjHJl7g4xAiL2kGlvVIE3kL57dNihN7ohI1dSgD1EBkDR6kw3QL52/RZzVhxyBkvfnp+99mzn5f54ReU3vwmVqKX9ragkJKsFJ3Coxy97i9d9zFn51ywsXOPg7eYki5bjmfNC5KxJqRpXw==", "file_map": { "50": { "source": "fn main(input: Field, enable: bool) {\n if enable {\n let hash = no_predicate_function(input);\n // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,\n // resulting in execution failure.\n // Safety: testing context\n unsafe { fail(hash) };\n }\n}\n\n#[no_predicates]\nfn no_predicate_function(enable: Field) -> Field {\n // if-statement ensures that an `EnableSideEffects` instruction is emitted.\n if enable == 0 {\n 1\n } else {\n 0\n }\n}\n\nunconstrained fn fail(_: Field) {\n assert(false);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index 7a18864efce..7608949dedf 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -36,9 +36,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 293 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 211 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 47 }, Jump { location: 45 }, Jump { location: 46 }, Return, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 129 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 293 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, 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: 298 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 309 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 302 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 296 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 212 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 46 }, Jump { location: 45 }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 128 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 294 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, 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: 301 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 312 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 305 }, Return]" ], - "debug_symbols": "pdXLbqNAEEDRf2HNAvpRVe1fGUURccgICWGL2CONIv/70NR1JllEmsfG1xjq2EZAvzXP49P1++O0vJxem8O3t+ZpneZ5+v44n47DZTot26dvTVdfojaHvm2i7Ul9cwhbgkc95il7cufxI7MfmaMnebJHPK5kV7Ir4oq4Iq6IK+KKuCKuiCviiriirqgr6oq6oq6oK+qKuqKuqCvmirlirpgr5oq5Yq6YK+aKuVJcKa4UV4orxZXiSnGluFJcKa70XUd7GmikiWYqVKnRzUtb+472NNBIE81UqFKjeAEv4AW8gBfwAl7AC3gBL5T9gutjR3saaKSJZipUqVG8hJfwEl7CS3gJL+ElvISX8DJexst4GS/jZbyMl/EyXsYTPMETPMETPMETPMETPMFTPMVTPMVTPMVTPMVTPMUzPMMzPMMzPMMzPMMzPMMrePW+yLWBRppopkKVGi17Q70/9vY00EgTzVSoUqN4PV49X1KbaKZClRot3nq+9vY0UDzDMzzDMzzDM7yCV/Dq+ZLbrW3uj+7HyzqO9cn94Vm+PeHPwzoul+awXOe5bX4M83U/6PU8LHsvw7rt7dpmXJ63buDLNI/13a39Pd19Pbr9E4ZjCO/j+Y/nY9T7vOZ/mS/3H5+CfTUfv57XwLjq+3SKn6bDf033fz/9sG0Nx2n9tC7fqrNOw9M8svlyXY4f9l5+nu977uv6eT0dx+frOlbpw+K+XRqhlDZ25aGuCftmbEOxh1v99l8=", + "debug_symbols": "pdXLbuJAEEDRf/GahftVVc2vjKKIEGdkyTLIgZFGEf8+btclkywizWPDxZg6gIW737rn4en6/XGcX06v3f7bW/e0jNM0fn+cTsfDZTzN66tvXd8eknb7sOuSbcmh28c10SMe9Zinbim9xweKD5TkyZ7icaW4Ulwprogr4oq4Iq6IK+KKuCKuiCviirqirqgr6oq6oq6oK+qKuqKumCvmirlirpgr5oq5Yq6YK+ZKdaW6Ul2prlRXqivVlepKdaW6EvqeBhppopkWKlTpyuXW6g09DTTSRDMtVKhSvIAX8SJexIt4ES/iRbyIF+v2fwupp4FGmmimhQpVahQv42W8jJfxMl7Gy3gZL+NlvIJX8ApewSt4Ba/gFbyCV/AET/AET/AET/AET/AET/AUT/EUT/EUT/EUT/EUT/EMz/AMz/AMz/AMz/AMz/AqXrsfSmukiWZaqFClRuvW2O6LrYFGmmimhQpVahQv4LXrJK2FClVqtHrbddoaaKSJ4hme4Rme4Rlexat4Fa9dJ7nddt195X68LMPQFu4PS/m6wJ8PyzBfuv18naZd9+MwXbc3vZ4P89bLYVnP9rtumJ/XruDLOA3t2W33e7r/enT9RQynGN/Hyx/Pp6T3eS3/Ml/vXz5H+2o+fT2vkXHV9+mcPk3H/5oOfz/9sB4djuPyaVu+NWcZD0/TwOHLdT5+OHv5eb6fuW/r5+V0HJ6vy9CkD3v7+tdIfdylEB/aXrAexiq71IeHW/v0Xw==", "file_map": { "43": { "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_0.snap index 7a18864efce..7608949dedf 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_0.snap @@ -36,9 +36,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 293 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 211 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 47 }, Jump { location: 45 }, Jump { location: 46 }, Return, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 129 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 293 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, 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: 298 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 309 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 302 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 296 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 212 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 46 }, Jump { location: 45 }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 128 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 294 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, 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: 301 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 312 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 305 }, Return]" ], - "debug_symbols": "pdXLbqNAEEDRf2HNAvpRVe1fGUURccgICWGL2CONIv/70NR1JllEmsfG1xjq2EZAvzXP49P1++O0vJxem8O3t+ZpneZ5+v44n47DZTot26dvTVdfojaHvm2i7Ul9cwhbgkc95il7cufxI7MfmaMnebJHPK5kV7Ir4oq4Iq6IK+KKuCKuiCviiriirqgr6oq6oq6oK+qKuqKuqCvmirlirpgr5oq5Yq6YK+aKuVJcKa4UV4orxZXiSnGluFJcKa70XUd7GmikiWYqVKnRzUtb+472NNBIE81UqFKjeAEv4AW8gBfwAl7AC3gBL5T9gutjR3saaKSJZipUqVG8hJfwEl7CS3gJL+ElvISX8DJexst4GS/jZbyMl/EyXsYTPMETPMETPMETPMETPMFTPMVTPMVTPMVTPMVTPMUzPMMzPMMzPMMzPMMzPMMrePW+yLWBRppopkKVGi17Q70/9vY00EgTzVSoUqN4PV49X1KbaKZClRot3nq+9vY0UDzDMzzDMzzDM7yCV/Dq+ZLbrW3uj+7HyzqO9cn94Vm+PeHPwzoul+awXOe5bX4M83U/6PU8LHsvw7rt7dpmXJ63buDLNI/13a39Pd19Pbr9E4ZjCO/j+Y/nY9T7vOZ/mS/3H5+CfTUfv57XwLjq+3SKn6bDf033fz/9sG0Nx2n9tC7fqrNOw9M8svlyXY4f9l5+nu977uv6eT0dx+frOlbpw+K+XRqhlDZ25aGuCftmbEOxh1v99l8=", + "debug_symbols": "pdXLbuJAEEDRf/GahftVVc2vjKKIEGdkyTLIgZFGEf8+btclkywizWPDxZg6gIW737rn4en6/XGcX06v3f7bW/e0jNM0fn+cTsfDZTzN66tvXd8eknb7sOuSbcmh28c10SMe9Zinbim9xweKD5TkyZ7icaW4Ulwprogr4oq4Iq6IK+KKuCKuiCviirqirqgr6oq6oq6oK+qKuqKumCvmirlirpgr5oq5Yq6YK+ZKdaW6Ul2prlRXqivVlepKdaW6EvqeBhppopkWKlTpyuXW6g09DTTSRDMtVKhSvIAX8SJexIt4ES/iRbyIF+v2fwupp4FGmmimhQpVahQv42W8jJfxMl7Gy3gZL+NlvIJX8ApewSt4Ba/gFbyCV/AET/AET/AET/AET/AET/AUT/EUT/EUT/EUT/EUT/EMz/AMz/AMz/AMz/AMz/AqXrsfSmukiWZaqFClRuvW2O6LrYFGmmimhQpVahQv4LXrJK2FClVqtHrbddoaaKSJ4hme4Rme4Rlexat4Fa9dJ7nddt195X68LMPQFu4PS/m6wJ8PyzBfuv18naZd9+MwXbc3vZ4P89bLYVnP9rtumJ/XruDLOA3t2W33e7r/enT9RQynGN/Hyx/Pp6T3eS3/Ml/vXz5H+2o+fT2vkXHV9+mcPk3H/5oOfz/9sB4djuPyaVu+NWcZD0/TwOHLdT5+OHv5eb6fuW/r5+V0HJ6vy9CkD3v7+tdIfdylEB/aXrAexiq71IeHW/v0Xw==", "file_map": { "43": { "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 7a18864efce..7608949dedf 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/regression_7323/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -36,9 +36,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 293 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 211 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 47 }, Jump { location: 45 }, Jump { location: 46 }, Return, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 129 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 293 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 299 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, 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: 298 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 309 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 302 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 12 }, Call { location: 13 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 296 }, Const { destination: Relative(2), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 66 }, Const { destination: Relative(4), bit_size: Integer(U8), value: 114 }, Const { destination: Relative(5), bit_size: Integer(U8), value: 97 }, Const { destination: Relative(6), bit_size: Integer(U8), value: 110 }, Const { destination: Relative(7), bit_size: Integer(U8), value: 99 }, Const { destination: Relative(8), bit_size: Integer(U8), value: 104 }, Const { destination: Relative(9), bit_size: Integer(U8), value: 32 }, Const { destination: Relative(10), bit_size: Integer(U8), value: 115 }, Const { destination: Relative(11), bit_size: Integer(U8), value: 111 }, Const { destination: Relative(12), bit_size: Integer(U8), value: 117 }, Const { destination: Relative(13), bit_size: Integer(U8), value: 108 }, Const { destination: Relative(14), bit_size: Integer(U8), value: 100 }, Const { destination: Relative(15), bit_size: Integer(U8), value: 116 }, Const { destination: Relative(16), bit_size: Integer(U8), value: 98 }, Const { destination: Relative(17), bit_size: Integer(U8), value: 101 }, Const { destination: Relative(18), bit_size: Integer(U8), value: 107 }, Const { destination: Relative(19), bit_size: Integer(U1), value: 0 }, Const { destination: Relative(20), bit_size: Integer(U1), value: 1 }, Const { destination: Relative(21), bit_size: Field, value: 0 }, JumpIf { condition: Relative(3), location: 212 }, Jump { location: 37 }, Const { destination: Relative(3), bit_size: Field, value: 2 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 129 }, Jump { location: 41 }, Const { destination: Relative(3), bit_size: Field, value: 3 }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(3) }, JumpIf { condition: Relative(22), location: 46 }, Jump { location: 45 }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 51 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 128 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 50 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 211 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, Const { destination: Relative(1), bit_size: Integer(U8), value: 49 }, Mov { destination: Relative(3), source: Direct(1) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(22) }, IndirectConst { destination_pointer: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Relative(23), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(2) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(4) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(7) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(1) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(10) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(8) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(12) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(13) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(14) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(11) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(16) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(9) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(15) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(5) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(18) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(17) }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(23), rhs: Direct(2) }, Store { destination_pointer: Relative(23), source: Relative(6) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U1, lhs: Relative(19), rhs: Relative(20) }, JumpIf { condition: Relative(1), location: 294 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 30 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(5) }, Mov { destination: Relative(5), source: Relative(4) }, IndirectConst { destination_pointer: Relative(5), bit_size: Integer(U64), value: 16078247100671166886 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 28 }, Mov { destination: Direct(32771), source: Relative(6) }, Mov { destination: Direct(32772), source: Relative(5) }, Mov { destination: Direct(32773), source: Relative(7) }, Call { location: 302 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 28 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(6) }, Store { destination_pointer: Relative(5), source: Relative(21) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Trap { revert_data: HeapVector { pointer: Relative(4), size: Relative(2) } }, Jump { location: 295 }, 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: 301 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 312 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 305 }, Return]" ], - "debug_symbols": "pdXLbqNAEEDRf2HNAvpRVe1fGUURccgICWGL2CONIv/70NR1JllEmsfG1xjq2EZAvzXP49P1++O0vJxem8O3t+ZpneZ5+v44n47DZTot26dvTVdfojaHvm2i7Ul9cwhbgkc95il7cufxI7MfmaMnebJHPK5kV7Ir4oq4Iq6IK+KKuCKuiCviiriirqgr6oq6oq6oK+qKuqKuqCvmirlirpgr5oq5Yq6YK+aKuVJcKa4UV4orxZXiSnGluFJcKa70XUd7GmikiWYqVKnRzUtb+472NNBIE81UqFKjeAEv4AW8gBfwAl7AC3gBL5T9gutjR3saaKSJZipUqVG8hJfwEl7CS3gJL+ElvISX8DJexst4GS/jZbyMl/EyXsYTPMETPMETPMETPMETPMFTPMVTPMVTPMVTPMVTPMUzPMMzPMMzPMMzPMMzPMMrePW+yLWBRppopkKVGi17Q70/9vY00EgTzVSoUqN4PV49X1KbaKZClRot3nq+9vY0UDzDMzzDMzzDM7yCV/Dq+ZLbrW3uj+7HyzqO9cn94Vm+PeHPwzoul+awXOe5bX4M83U/6PU8LHsvw7rt7dpmXJ63buDLNI/13a39Pd19Pbr9E4ZjCO/j+Y/nY9T7vOZ/mS/3H5+CfTUfv57XwLjq+3SKn6bDf033fz/9sG0Nx2n9tC7fqrNOw9M8svlyXY4f9l5+nu977uv6eT0dx+frOlbpw+K+XRqhlDZ25aGuCftmbEOxh1v99l8=", + "debug_symbols": "pdXLbuJAEEDRf/GahftVVc2vjKKIEGdkyTLIgZFGEf8+btclkywizWPDxZg6gIW737rn4en6/XGcX06v3f7bW/e0jNM0fn+cTsfDZTzN66tvXd8eknb7sOuSbcmh28c10SMe9Zinbim9xweKD5TkyZ7icaW4Ulwprogr4oq4Iq6IK+KKuCKuiCviirqirqgr6oq6oq6oK+qKuqKumCvmirlirpgr5oq5Yq6YK+ZKdaW6Ul2prlRXqivVlepKdaW6EvqeBhppopkWKlTpyuXW6g09DTTSRDMtVKhSvIAX8SJexIt4ES/iRbyIF+v2fwupp4FGmmimhQpVahQv42W8jJfxMl7Gy3gZL+NlvIJX8ApewSt4Ba/gFbyCV/AET/AET/AET/AET/AET/AUT/EUT/EUT/EUT/EUT/EMz/AMz/AMz/AMz/AMz/AqXrsfSmukiWZaqFClRuvW2O6LrYFGmmimhQpVahQv4LXrJK2FClVqtHrbddoaaKSJ4hme4Rme4Rlexat4Fa9dJ7nddt195X68LMPQFu4PS/m6wJ8PyzBfuv18naZd9+MwXbc3vZ4P89bLYVnP9rtumJ/XruDLOA3t2W33e7r/enT9RQynGN/Hyx/Pp6T3eS3/Ml/vXz5H+2o+fT2vkXHV9+mcPk3H/5oOfz/9sB4djuPyaVu+NWcZD0/TwOHLdT5+OHv5eb6fuW/r5+V0HJ6vy9CkD3v7+tdIfdylEB/aXrAexiq71IeHW/v0Xw==", "file_map": { "43": { "source": "pub fn panic(message: fmtstr) -> U {\n assert(false, message);\n crate::mem::zeroed()\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index cdab82ce182..b1a9be1926a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32859 }, 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(32858), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32858) }, Call { location: 13 }, Call { location: 37 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32859 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Field, 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: Field, value: 1 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32841), bit_size: Field, value: 2 }, Const { destination: Direct(32842), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32843), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32844), bit_size: Field, value: 4 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32846), bit_size: Field, value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 10 }, Const { destination: Direct(32852), bit_size: Field, value: 10 }, Const { destination: Direct(32853), bit_size: Field, value: 15 }, Const { destination: Direct(32854), bit_size: Integer(U32), value: 20 }, Const { destination: Direct(32855), bit_size: Field, value: 20 }, Const { destination: Direct(32856), bit_size: Field, value: 22 }, Const { destination: Direct(32857), bit_size: Field, value: 30 }, Return, Call { location: 54 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 42 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32843) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 46 }, Call { location: 60 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, Mov { destination: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 63 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 59 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: 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(4) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 84 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 303 }, Jump { location: 87 }, Load { destination: Relative(3), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(4) }, 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: 95 }, Call { location: 326 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(5), location: 101 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 107 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Direct(32845) }, Mov { destination: Relative(9), source: Relative(4) }, Mov { destination: Relative(10), source: Relative(1) }, Mov { destination: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 329 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 124 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Direct(32845) }, Mov { destination: Relative(10), source: Relative(4) }, Mov { destination: Relative(11), source: Relative(1) }, Mov { destination: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 434 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 141 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Direct(32845) }, Mov { destination: Relative(11), source: Relative(4) }, Mov { destination: Relative(12), source: Relative(1) }, Mov { destination: Relative(13), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 530 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 158 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(10), location: 164 }, Call { location: 747 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, Mov { destination: Relative(15), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(10) }, Call { location: 750 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(3) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 179 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 865 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Field, value: 3 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Direct(32836) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32839) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32841) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32844) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Relative(11) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 914 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(3) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 218 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Direct(32845) }, Mov { destination: Relative(14), source: Relative(4) }, Mov { destination: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 958 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 234 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 13 }, Mov { destination: Relative(13), source: Direct(0) }, Mov { destination: Relative(14), source: Direct(32845) }, Mov { destination: Relative(15), source: Relative(4) }, Mov { destination: Relative(16), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1012 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 14 }, Mov { destination: Relative(14), source: Direct(0) }, Mov { destination: Relative(15), source: Direct(32845) }, Mov { destination: Relative(16), source: Relative(4) }, Mov { destination: Relative(17), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1413 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 266 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 15 }, Mov { destination: Relative(15), source: Direct(0) }, Mov { destination: Relative(16), source: Direct(32845) }, Mov { destination: Relative(17), source: Relative(4) }, Mov { destination: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1548 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 282 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1749 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 2023 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Load { destination: Relative(4), source_pointer: Relative(5) }, Load { destination: Relative(7), source_pointer: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(7) }, 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: 311 }, Call { location: 326 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Store { destination_pointer: Relative(6), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 84 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 335 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 343 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 346 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 354 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 370 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 373 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 379 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 391 }, Jump { location: 382 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 414 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 402 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 405 }, Call { location: 2284 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 414 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32842), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 418 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32841) }, JumpIf { condition: Relative(4), location: 424 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 427 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 433 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 440 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 448 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 451 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 459 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 475 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 478 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 484 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, JumpIf { condition: Relative(2), location: 496 }, Jump { location: 487 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 519 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 507 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 510 }, Call { location: 2284 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 519 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 523 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 529 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 538 }, Call { location: 2284 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 546 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 549 }, Call { location: 2284 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 557 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 574 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 577 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 583 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 596 }, Jump { location: 586 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Jump { location: 670 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(7), location: 618 }, Jump { location: 608 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 670 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 743 }, Jump { location: 621 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 634 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 651 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 657 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 658 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 663 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 669 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 670 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 675 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32852) }, JumpIf { condition: Relative(4), location: 681 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 687 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 693 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 699 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(7), location: 707 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 713 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 730 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 736 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 742 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Return, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Direct(32841), rhs: Direct(32856) }, JumpIf { condition: Relative(1), location: 747 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 756 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 764 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 767 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32841) }, JumpIf { condition: Relative(7), location: 775 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 791 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 794 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 800 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 813 }, Jump { location: 804 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(4), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Jump { location: 855 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2287 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(2), location: 846 }, Jump { location: 824 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32843) }, JumpIf { condition: Relative(2), location: 827 }, Jump { location: 836 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32846) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 836 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 839 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 845 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 855 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 855 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 858 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 864 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 884 }, Jump { location: 873 }, JumpIf { condition: Relative(6), location: 875 }, Call { location: 2284 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 883 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 903 }, JumpIf { condition: Relative(6), location: 886 }, Call { location: 2284 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 894 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 903 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 907 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 913 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 932 }, Jump { location: 922 }, JumpIf { condition: Relative(5), location: 924 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(4), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 931 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 950 }, JumpIf { condition: Relative(5), location: 934 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(4), rhs: Direct(32844) }, JumpIf { condition: Relative(5), location: 941 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2313 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Store { destination_pointer: Relative(6), source: Direct(32841) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 950 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32841) }, JumpIf { condition: Relative(1), location: 957 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 990 }, Jump { location: 966 }, JumpIf { condition: Relative(6), location: 968 }, Call { location: 2284 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 976 }, 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: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Sub, lhs: Relative(5), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 1001 }, JumpIf { condition: Relative(6), location: 992 }, Call { location: 2284 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 1000 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 1001 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1005 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 1011 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1051 }, Jump { location: 1023 }, JumpIf { condition: Relative(7), location: 1025 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(3), location: 1033 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1039 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1392 }, JumpIf { condition: Relative(7), location: 1053 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1061 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1074 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1086 }, Call { location: 2284 }, Mov { destination: Direct(32771), source: Relative(8) }, Call { location: 2287 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Load { destination: Relative(6), source_pointer: Relative(1) }, 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: 1099 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1105 }, Call { location: 60 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1108 }, Call { location: 2284 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(9), rhs: Direct(32852) }, JumpIf { condition: Relative(6), location: 1116 }, 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(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1122 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1128 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2287 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Load { destination: Relative(2), source_pointer: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1148 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(2), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2335 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 1161 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32842) }, Load { destination: Relative(1), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(12), location: 1167 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1173 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1179 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(10), location: 1185 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1191 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2335 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Store { destination_pointer: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 1204 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, Load { destination: Relative(11), source_pointer: Relative(14) }, BinaryFieldOp { destination: Relative(14), op: Equals, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(14), location: 1210 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1216 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, JumpIf { condition: Relative(11), location: 1222 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32850) }, Load { destination: Relative(11), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(11), rhs: Direct(32857) }, JumpIf { condition: Relative(12), location: 1228 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1234 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2390 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Load { destination: Relative(16), source_pointer: Relative(17) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1249 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(16), rhs: Direct(32852) }, JumpIf { condition: Relative(13), location: 1255 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1261 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(13), location: 1267 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(20) }, Load { destination: Relative(13), source_pointer: Relative(19) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2427 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1279 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(18) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1285 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1291 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Direct(32840), rhs: Relative(3) }, JumpIf { condition: Relative(11), location: 1295 }, Call { location: 60 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(11), location: 1298 }, Call { location: 2284 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(19), rhs: Relative(1) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Mov { destination: Direct(32772), source: Relative(19) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2469 }, Mov { destination: Relative(15), source: Direct(32774) }, Mov { destination: Relative(20), source: Direct(32775) }, Store { destination_pointer: Relative(20), source: Direct(32855) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1311 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32845) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(18), location: 1317 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32847), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1320 }, Call { location: 2284 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(18), location: 1326 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1332 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1338 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1344 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(19), location: 1350 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(3), location: 1353 }, Call { location: 2284 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(20) }, Load { destination: Relative(21), source_pointer: Relative(22) }, Mov { destination: Direct(32771), source: Relative(15) }, Mov { destination: Direct(32772), source: Relative(20) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2538 }, Mov { destination: Relative(19), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1371 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(19) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(1), location: 1379 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 1385 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1391 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Jump { location: 1392 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1400 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1406 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(2), location: 1412 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1464 }, Jump { location: 1424 }, JumpIf { condition: Relative(7), location: 1426 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1434 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1452 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1484 }, JumpIf { condition: Relative(7), location: 1466 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1474 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1484 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1492 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1498 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1504 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(7), location: 1512 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1518 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1535 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 1541 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 1547 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1599 }, Jump { location: 1559 }, JumpIf { condition: Relative(7), location: 1561 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1569 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1587 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 1619 }, JumpIf { condition: Relative(7), location: 1601 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1609 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1619 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1627 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1633 }, 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(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1639 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 1647 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1650 }, Jump { location: 1670 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1658 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1670 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1678 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1693 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1699 }, 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(7) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1705 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(8), location: 1713 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1719 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(9) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1736 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, JumpIf { condition: Relative(4), location: 1742 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(1), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(4), location: 1748 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Cast { destination: Relative(9), source: Relative(3), bit_size: Field }, Const { destination: Relative(10), bit_size: Field, value: 50 }, JumpIf { condition: Relative(7), location: 1805 }, Jump { location: 1762 }, JumpIf { condition: Relative(8), location: 1764 }, Call { location: 2284 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1777 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(2) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1793 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1837 }, JumpIf { condition: Relative(8), location: 1807 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(4), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1825 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 1837 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1845 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1862 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32849) }, JumpIf { condition: Relative(1), location: 1868 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1871 }, Jump { location: 1889 }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1877 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1889 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, 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: 1897 }, Call { location: 326 }, 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(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Store { destination_pointer: Relative(6), source: Relative(9) }, JumpIf { condition: Relative(1), location: 1928 }, Jump { location: 1910 }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 1916 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 1928 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1936 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1954 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1961 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1964 }, Call { location: 2284 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(5), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 1972 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 1978 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(3), rhs: Direct(32857) }, JumpIf { condition: Relative(6), location: 1986 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1992 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32853) }, JumpIf { condition: Relative(1), location: 2000 }, 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(9) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2006 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 2015 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 2022 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(9), source: Relative(4), bit_size: Field }, JumpIf { condition: Relative(7), location: 2125 }, Jump { location: 2035 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 2038 }, Call { location: 2284 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2287 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32846) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2051 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(10) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 2066 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(2) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2081 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 2087 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2093 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2390 }, Mov { destination: Relative(12), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(12) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(14) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 2108 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 2116 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 2122 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 2143 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2131 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Jump { location: 2143 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2151 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2168 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 2174 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 2177 }, Jump { location: 2195 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2183 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2228 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 2195 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2390 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2210 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Direct(32857) }, JumpIf { condition: Relative(1), location: 2216 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2390 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 2227 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2239 }, Jump { location: 2256 }, JumpIf { condition: Direct(32781), location: 2241 }, Jump { location: 2245 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2255 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2255 }, Jump { location: 2268 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2268 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2282 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2282 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2275 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2291 }, Jump { location: 2293 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2312 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2310 }, 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: 2303 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2312 }, 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: 2317 }, Jump { location: 2319 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2334 }, 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: 2331 }, 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: 2324 }, 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: 2334 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2346 }, Jump { location: 2363 }, JumpIf { condition: Direct(32781), location: 2348 }, Jump { location: 2352 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2362 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2362 }, Jump { location: 2375 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2375 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2388 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2381 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2399 }, Jump { location: 2403 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2425 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2424 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2417 }, Jump { location: 2425 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2437 }, Jump { location: 2445 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2468 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2467 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2460 }, Jump { location: 2468 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2480 }, Jump { location: 2497 }, JumpIf { condition: Direct(32782), location: 2482 }, Jump { location: 2486 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2496 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2496 }, Jump { location: 2509 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2509 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2523 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2523 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2516 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2537 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2530 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2547 }, Jump { location: 2553 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2575 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2574 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2567 }, Jump { location: 2575 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2590 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2583 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32859 }, 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(32858), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32858), source: Direct(32858), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32858) }, Call { location: 13 }, Call { location: 37 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32859 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Const { destination: Direct(32835), bit_size: Integer(U32), value: 0 }, Const { destination: Direct(32836), bit_size: Field, 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: Field, value: 1 }, Const { destination: Direct(32840), bit_size: Integer(U32), value: 2 }, Const { destination: Direct(32841), bit_size: Field, value: 2 }, Const { destination: Direct(32842), bit_size: Integer(U32), value: 3 }, Const { destination: Direct(32843), bit_size: Integer(U32), value: 4 }, Const { destination: Direct(32844), bit_size: Field, value: 4 }, Const { destination: Direct(32845), bit_size: Integer(U32), value: 5 }, Const { destination: Direct(32846), bit_size: Field, value: 5 }, Const { destination: Direct(32847), bit_size: Integer(U32), value: 6 }, Const { destination: Direct(32848), bit_size: Integer(U32), value: 7 }, Const { destination: Direct(32849), bit_size: Integer(U32), value: 8 }, Const { destination: Direct(32850), bit_size: Integer(U32), value: 9 }, Const { destination: Direct(32851), bit_size: Integer(U32), value: 10 }, Const { destination: Direct(32852), bit_size: Field, value: 10 }, Const { destination: Direct(32853), bit_size: Field, value: 15 }, Const { destination: Direct(32854), bit_size: Integer(U32), value: 20 }, Const { destination: Direct(32855), bit_size: Field, value: 20 }, Const { destination: Direct(32856), bit_size: Field, value: 22 }, Const { destination: Direct(32857), bit_size: Field, value: 30 }, Return, Call { location: 54 }, BinaryIntOp { destination: Relative(2), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(3), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 42 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(32843) }, BinaryIntOp { destination: Relative(4), op: LessThanEquals, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 46 }, Call { location: 60 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 4 }, Mov { destination: Relative(4), source: Direct(0) }, Mov { destination: Relative(5), source: Relative(2) }, Mov { destination: Relative(6), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(1) }, Call { location: 63 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 59 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(5) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: 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(4) }, Mov { destination: Relative(3), source: Direct(32835) }, Jump { location: 84 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 303 }, Jump { location: 87 }, Load { destination: Relative(3), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(4) }, 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: 95 }, Call { location: 326 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(5), location: 101 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 107 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 7 }, Mov { destination: Relative(7), source: Direct(0) }, Mov { destination: Relative(8), source: Direct(32845) }, Mov { destination: Relative(9), source: Relative(4) }, Mov { destination: Relative(10), source: Relative(1) }, Mov { destination: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 329 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 124 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 8 }, Mov { destination: Relative(8), source: Direct(0) }, Mov { destination: Relative(9), source: Direct(32845) }, Mov { destination: Relative(10), source: Relative(4) }, Mov { destination: Relative(11), source: Relative(1) }, Mov { destination: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 434 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 141 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 9 }, Mov { destination: Relative(9), source: Direct(0) }, Mov { destination: Relative(10), source: Direct(32845) }, Mov { destination: Relative(11), source: Relative(4) }, Mov { destination: Relative(12), source: Relative(1) }, Mov { destination: Relative(13), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 530 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 158 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(10), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, JumpIf { condition: Relative(10), location: 164 }, Call { location: 748 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, Mov { destination: Relative(15), source: Relative(3) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(10) }, Call { location: 751 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(3) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 179 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 11 }, Mov { destination: Relative(11), source: Direct(0) }, Mov { destination: Relative(12), source: Direct(32845) }, Mov { destination: Relative(13), source: Relative(4) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 866 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Field, value: 3 }, Mov { destination: Relative(11), source: Direct(1) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(12) }, IndirectConst { destination_pointer: Relative(11), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Relative(13), source: Relative(12) }, Store { destination_pointer: Relative(13), source: Direct(32836) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32839) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32841) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(3) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Direct(32844) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Relative(11) }, Mov { destination: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 915 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(3) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 218 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 12 }, Mov { destination: Relative(12), source: Direct(0) }, Mov { destination: Relative(13), source: Direct(32845) }, Mov { destination: Relative(14), source: Relative(4) }, Mov { destination: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 959 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 234 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 13 }, Mov { destination: Relative(13), source: Direct(0) }, Mov { destination: Relative(14), source: Direct(32845) }, Mov { destination: Relative(15), source: Relative(4) }, Mov { destination: Relative(16), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1013 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), 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(3) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 14 }, Mov { destination: Relative(14), source: Direct(0) }, Mov { destination: Relative(15), source: Direct(32845) }, Mov { destination: Relative(16), source: Relative(4) }, Mov { destination: Relative(17), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1414 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(3) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 266 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 15 }, Mov { destination: Relative(15), source: Direct(0) }, Mov { destination: Relative(16), source: Direct(32845) }, Mov { destination: Relative(17), source: Relative(4) }, Mov { destination: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1549 }, Mov { destination: Direct(0), source: Relative(0) }, Load { destination: Relative(3), source_pointer: Relative(4) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(3) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 282 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 1750 }, Mov { destination: Direct(0), source: Relative(0) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 16 }, Mov { destination: Relative(16), source: Direct(0) }, Mov { destination: Relative(17), source: Direct(32845) }, Mov { destination: Relative(18), source: Relative(4) }, Mov { destination: Relative(19), source: Relative(1) }, Mov { destination: Relative(20), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(3) }, Call { location: 2024 }, Mov { destination: Direct(0), source: Relative(0) }, Return, Load { destination: Relative(4), source_pointer: Relative(5) }, Load { destination: Relative(7), source_pointer: Relative(6) }, Load { destination: Relative(8), source_pointer: Relative(7) }, 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: 311 }, Call { location: 326 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(10) }, Store { destination_pointer: Relative(6), source: Relative(11) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, Mov { destination: Relative(3), source: Relative(4) }, Jump { location: 84 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 335 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 343 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 346 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 354 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 370 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 373 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 379 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 391 }, Jump { location: 382 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 414 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 402 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 405 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 414 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32842), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 418 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32841) }, JumpIf { condition: Relative(4), location: 424 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 427 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 433 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 440 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 448 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 451 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32839) }, JumpIf { condition: Relative(7), location: 459 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(4), location: 475 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 478 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 484 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, JumpIf { condition: Relative(2), location: 496 }, Jump { location: 487 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 519 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(6), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(6), location: 507 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 510 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(3), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(4) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Jump { location: 519 }, Load { destination: Relative(2), source_pointer: Relative(5) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 523 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 529 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 538 }, Call { location: 2285 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 546 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 549 }, Call { location: 2285 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(7), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 557 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(9) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(8), location: 574 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32838), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 577 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32843) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(8), location: 583 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, JumpIf { condition: Relative(2), location: 596 }, Jump { location: 586 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Jump { location: 675 }, Mov { destination: Direct(32771), source: Relative(7) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(7), location: 618 }, Jump { location: 608 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 675 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 658 }, Jump { location: 621 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 634 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 651 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 657 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Jump { location: 663 }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Direct(32841), rhs: Direct(32856) }, JumpIf { condition: Relative(1), location: 662 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 663 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 668 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 674 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 675 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 680 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(3), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(3), rhs: Direct(32852) }, JumpIf { condition: Relative(4), location: 686 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 692 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 698 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 704 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(7), location: 712 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 718 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 735 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 741 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 747 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 757 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 765 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 768 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32841) }, JumpIf { condition: Relative(7), location: 776 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 792 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 795 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 801 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 814 }, Jump { location: 805 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(4), source: Direct(32836) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Jump { location: 856 }, Mov { destination: Direct(32771), source: Relative(6) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(5), source: Relative(1) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32838) }, JumpIf { condition: Relative(2), location: 847 }, Jump { location: 825 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32843) }, JumpIf { condition: Relative(2), location: 828 }, Jump { location: 837 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32846) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 837 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 840 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 846 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 856 }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Store { destination_pointer: Relative(6), source: Direct(32856) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Jump { location: 856 }, Load { destination: Relative(1), source_pointer: Relative(5) }, JumpIf { condition: Relative(7), location: 859 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32846) }, JumpIf { condition: Relative(1), location: 865 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 885 }, Jump { location: 874 }, JumpIf { condition: Relative(6), location: 876 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 884 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 904 }, JumpIf { condition: Relative(6), location: 887 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 895 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(7), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 904 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 908 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 914 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32845) }, JumpIf { condition: Relative(4), location: 933 }, Jump { location: 923 }, JumpIf { condition: Relative(5), location: 925 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(4), rhs: Direct(32836) }, JumpIf { condition: Relative(1), location: 932 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Jump { location: 951 }, JumpIf { condition: Relative(5), location: 935 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Load { destination: Relative(4), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(4), rhs: Direct(32844) }, JumpIf { condition: Relative(5), location: 942 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2314 }, Mov { destination: Relative(4), source: Direct(32773) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, Store { destination_pointer: Relative(6), source: Direct(32841) }, Store { destination_pointer: Relative(3), source: Relative(4) }, Jump { location: 951 }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(32845) }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(2), rhs: Direct(32841) }, JumpIf { condition: Relative(1), location: 958 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(2) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 991 }, Jump { location: 967 }, JumpIf { condition: Relative(6), location: 969 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(5), rhs: Direct(32844) }, JumpIf { condition: Relative(6), location: 977 }, 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: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Sub, lhs: Relative(5), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Store { destination_pointer: Relative(4), source: Relative(5) }, Jump { location: 1002 }, JumpIf { condition: Relative(6), location: 993 }, Call { location: 2285 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(5), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 1001 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Jump { location: 1002 }, Load { destination: Relative(2), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Direct(32843), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1006 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32848) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32841) }, JumpIf { condition: Relative(2), location: 1012 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Direct(32851) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1052 }, Jump { location: 1024 }, JumpIf { condition: Relative(7), location: 1026 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(3), location: 1034 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1040 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1393 }, JumpIf { condition: Relative(7), location: 1054 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1062 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1075 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1087 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(8) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Load { destination: Relative(6), source_pointer: Relative(1) }, 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: 1100 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(9), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1106 }, Call { location: 60 }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 1109 }, Call { location: 2285 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(6) }, Load { destination: Relative(9), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(9), rhs: Direct(32852) }, JumpIf { condition: Relative(6), location: 1117 }, 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(1) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(9), rhs: Relative(6) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1123 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1129 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Mov { destination: Direct(32771), source: Relative(1) }, Call { location: 2288 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(1), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Load { destination: Relative(2), source_pointer: Relative(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1149 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(1), source: Relative(2) }, Const { destination: Relative(2), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(1) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2336 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 1162 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32842) }, Load { destination: Relative(1), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(12), location: 1168 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1174 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1180 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(10), location: 1186 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 1192 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, Const { destination: Relative(1), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2336 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Store { destination_pointer: Relative(14), source: Relative(1) }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Direct(32835), rhs: Relative(12) }, JumpIf { condition: Relative(11), location: 1205 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32842) }, Load { destination: Relative(11), source_pointer: Relative(14) }, BinaryFieldOp { destination: Relative(14), op: Equals, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(14), location: 1211 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1217 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Direct(32849) }, JumpIf { condition: Relative(11), location: 1223 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(32850) }, Load { destination: Relative(11), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(12), op: Equals, lhs: Relative(11), rhs: Direct(32857) }, JumpIf { condition: Relative(12), location: 1229 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1235 }, Call { location: 326 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Load { destination: Relative(16), source_pointer: Relative(17) }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1250 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(16), rhs: Direct(32852) }, JumpIf { condition: Relative(13), location: 1256 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(13), source_pointer: Relative(15) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1262 }, Call { location: 326 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(13), location: 1268 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(20) }, Load { destination: Relative(13), source_pointer: Relative(19) }, Mov { destination: Direct(32771), source: Relative(15) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2428 }, Mov { destination: Relative(18), source: Direct(32773) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(13), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1280 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(18) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1286 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1292 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32840) }, BinaryIntOp { destination: Relative(11), op: LessThanEquals, bit_size: U32, lhs: Direct(32840), rhs: Relative(3) }, JumpIf { condition: Relative(11), location: 1296 }, Call { location: 60 }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(11), location: 1299 }, Call { location: 2285 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(19), op: Mul, bit_size: U32, lhs: Relative(19), rhs: Relative(1) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Mov { destination: Direct(32772), source: Relative(19) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2470 }, Mov { destination: Relative(15), source: Direct(32774) }, Mov { destination: Relative(20), source: Direct(32775) }, Store { destination_pointer: Relative(20), source: Direct(32855) }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32840), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1312 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32845) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(18), location: 1318 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Direct(32847), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1321 }, Call { location: 2285 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(15), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(18), location: 1327 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1333 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1339 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Load { destination: Relative(1), source_pointer: Relative(15) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(19), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, Not { destination: Relative(19), source: Relative(19), bit_size: U1 }, JumpIf { condition: Relative(19), location: 1345 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(15), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(32838) }, BinaryIntOp { destination: Relative(19), op: LessThanEquals, bit_size: U32, lhs: Direct(32838), rhs: Relative(3) }, JumpIf { condition: Relative(19), location: 1351 }, Call { location: 60 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(3), location: 1354 }, Call { location: 2285 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(20), op: Mul, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Const { destination: Relative(23), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(23) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(20) }, Load { destination: Relative(21), source_pointer: Relative(22) }, Mov { destination: Direct(32771), source: Relative(15) }, Mov { destination: Direct(32772), source: Relative(20) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2539 }, Mov { destination: Relative(19), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1372 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(19) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(21), rhs: Direct(32839) }, JumpIf { condition: Relative(1), location: 1380 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(1), source_pointer: Relative(19) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(20), rhs: Relative(1) }, Not { destination: Relative(21), source: Relative(21), bit_size: U1 }, JumpIf { condition: Relative(21), location: 1386 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(19), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32847) }, JumpIf { condition: Relative(1), location: 1392 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Jump { location: 1393 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1401 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1407 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32857) }, JumpIf { condition: Relative(2), location: 1413 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1465 }, Jump { location: 1425 }, JumpIf { condition: Relative(7), location: 1427 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1435 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1453 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1485 }, JumpIf { condition: Relative(7), location: 1467 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1475 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1485 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1493 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(3), location: 1499 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Load { destination: Relative(1), source_pointer: Relative(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1505 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(7), location: 1513 }, 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(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1519 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32847), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1536 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 1542 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(2) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(2), location: 1548 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Return, Call { location: 54 }, 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: Relative(1) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Direct(32851), rhs: Relative(3) }, BinaryIntOp { destination: Relative(7), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(6), location: 1600 }, Jump { location: 1560 }, JumpIf { condition: Relative(7), location: 1562 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32844) }, JumpIf { condition: Relative(7), location: 1570 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(6), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(9), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1588 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32852) }, Store { destination_pointer: Relative(4), source: Relative(2) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Jump { location: 1620 }, JumpIf { condition: Relative(7), location: 1602 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(6), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Equals, lhs: Relative(6), rhs: Direct(32836) }, JumpIf { condition: Relative(7), location: 1610 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(6), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(8), source: Direct(32841) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(6) }, Jump { location: 1620 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(6), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1628 }, Call { location: 326 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(6), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32847) }, JumpIf { condition: Relative(6), location: 1634 }, 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(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1640 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32849) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(2), op: Equals, lhs: Relative(1), rhs: Direct(32852) }, JumpIf { condition: Relative(2), location: 1648 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1651 }, Jump { location: 1671 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1659 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(3) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Jump { location: 1671 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1679 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Direct(32853) }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1694 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 1700 }, 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(7) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1706 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(32850) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(1), rhs: Direct(32853) }, JumpIf { condition: Relative(8), location: 1714 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1720 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32855) }, Store { destination_pointer: Relative(4), source: Relative(1) }, Store { destination_pointer: Relative(5), source: Relative(9) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1737 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32849) }, JumpIf { condition: Relative(4), location: 1743 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(1), source_pointer: Relative(4) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(1), rhs: Direct(32855) }, JumpIf { condition: Relative(4), location: 1749 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(7) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Cast { destination: Relative(9), source: Relative(3), bit_size: Field }, Const { destination: Relative(10), bit_size: Field, value: 50 }, JumpIf { condition: Relative(7), location: 1806 }, Jump { location: 1763 }, JumpIf { condition: Relative(8), location: 1765 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(7), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(10) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1778 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(2) }, Cast { destination: Relative(2), source: Relative(4), bit_size: Field }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(7) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(2) }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1794 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1838 }, JumpIf { condition: Relative(8), location: 1808 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Load { destination: Relative(4), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Sub, lhs: Relative(4), rhs: Direct(32841) }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Store { destination_pointer: Relative(11), source: Relative(7) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1826 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Jump { location: 1838 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1846 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1863 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32849) }, JumpIf { condition: Relative(1), location: 1869 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 1872 }, Jump { location: 1890 }, Load { destination: Relative(2), source_pointer: Relative(8) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(7), source: Relative(7), bit_size: U1 }, JumpIf { condition: Relative(7), location: 1878 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Direct(32849), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(7), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(2) }, Store { destination_pointer: Relative(6), source: Relative(7) }, Jump { location: 1890 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Load { destination: Relative(4), source_pointer: Relative(6) }, 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: 1898 }, Call { location: 326 }, 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(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Direct(32853) }, Store { destination_pointer: Relative(5), source: Relative(7) }, Store { destination_pointer: Relative(6), source: Relative(9) }, JumpIf { condition: Relative(1), location: 1929 }, Jump { location: 1911 }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(4), source: Relative(4), bit_size: U1 }, JumpIf { condition: Relative(4), location: 1917 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(10) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Jump { location: 1929 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1937 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, Const { destination: Relative(4), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(4) }, Store { destination_pointer: Relative(5), source: Relative(8) }, Store { destination_pointer: Relative(6), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1955 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1962 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 1965 }, Call { location: 2285 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Load { destination: Relative(5), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(5), rhs: Relative(10) }, JumpIf { condition: Relative(3), location: 1973 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(6), source: Relative(6), bit_size: U1 }, JumpIf { condition: Relative(6), location: 1979 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(32851) }, Load { destination: Relative(3), source_pointer: Relative(6) }, BinaryFieldOp { destination: Relative(6), op: Equals, lhs: Relative(3), rhs: Direct(32857) }, JumpIf { condition: Relative(6), location: 1987 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(8) } }, Load { destination: Relative(3), source_pointer: Relative(9) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1993 }, Call { location: 326 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(3), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(3), rhs: Direct(32853) }, JumpIf { condition: Relative(1), location: 2001 }, 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(9) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2007 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(11) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(10) }, JumpIf { condition: Relative(1), location: 2016 }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(11) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(1) }, Load { destination: Relative(8), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(8), rhs: Relative(4) }, JumpIf { condition: Relative(1), location: 2023 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, Return, Call { location: 54 }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, 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(2) }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Cast { destination: Relative(8), source: Relative(3), bit_size: Field }, Cast { destination: Relative(9), source: Relative(4), bit_size: Field }, JumpIf { condition: Relative(7), location: 2126 }, Jump { location: 2036 }, BinaryIntOp { destination: Relative(4), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 2039 }, Call { location: 2285 }, Mov { destination: Direct(32771), source: Relative(2) }, Call { location: 2288 }, Mov { destination: Relative(4), source: Direct(32772) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(3) }, Store { destination_pointer: Relative(10), source: Direct(32846) }, Load { destination: Relative(2), source_pointer: Relative(4) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(2) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2052 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(9) }, Load { destination: Relative(1), source_pointer: Relative(10) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 2067 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(10) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(12), source: Direct(32774) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Load { destination: Relative(2), source_pointer: Relative(11) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(2) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2082 }, Call { location: 326 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Direct(32848) }, JumpIf { condition: Relative(2), location: 2088 }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(12) } }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 2094 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(12), source: Direct(32773) }, Mov { destination: Relative(14), source: Direct(32774) }, Load { destination: Relative(13), source_pointer: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(12) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(14) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 2109 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(12), source: Relative(14) }, Load { destination: Relative(14), source_pointer: Relative(11) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(17), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(14) }, Not { destination: Relative(17), source: Relative(17), bit_size: U1 }, JumpIf { condition: Relative(17), location: 2117 }, Call { location: 326 }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(14), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(13), rhs: Relative(8) }, JumpIf { condition: Relative(11), location: 2123 }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(14) } }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(12) }, Jump { location: 2144 }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2132 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(11), source: Direct(32774) }, Store { destination_pointer: Relative(11), source: Relative(8) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(10) }, Jump { location: 2144 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(7), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 2152 }, Call { location: 326 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Direct(32857) }, Store { destination_pointer: Relative(5), source: Relative(4) }, Store { destination_pointer: Relative(6), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 2169 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Direct(32848) }, JumpIf { condition: Relative(1), location: 2175 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Direct(32854) }, JumpIf { condition: Relative(1), location: 2178 }, Jump { location: 2196 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2184 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Direct(32848), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2229 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Direct(32855) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(6), source: Relative(3) }, Jump { location: 2196 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(2), source_pointer: Relative(6) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2211 }, Call { location: 326 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Direct(32857) }, JumpIf { condition: Relative(1), location: 2217 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2391 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(9) }, JumpIf { condition: Relative(3), location: 2228 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2240 }, Jump { location: 2257 }, JumpIf { condition: Direct(32781), location: 2242 }, Jump { location: 2246 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2256 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2256 }, Jump { location: 2269 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2269 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2283 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2283 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2276 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2292 }, Jump { location: 2294 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2313 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2311 }, 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: 2304 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2313 }, 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: 2318 }, Jump { location: 2320 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2335 }, 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: 2332 }, 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: 2325 }, 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: 2335 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2347 }, Jump { location: 2364 }, JumpIf { condition: Direct(32781), location: 2349 }, Jump { location: 2353 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2363 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2363 }, Jump { location: 2376 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2376 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2389 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2382 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2400 }, Jump { location: 2404 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2426 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2425 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2418 }, Jump { location: 2426 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2438 }, Jump { location: 2446 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2469 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2468 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2461 }, Jump { location: 2469 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2481 }, Jump { location: 2498 }, JumpIf { condition: Direct(32782), location: 2483 }, Jump { location: 2487 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2497 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2497 }, Jump { location: 2510 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2510 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2524 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2524 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2517 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2538 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2531 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2548 }, Jump { location: 2554 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2576 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2575 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2568 }, Jump { location: 2576 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2591 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2584 }, Return]" ], - "debug_symbols": "pd3RriW3zSXgd+lrX5REkZT8KkZgOIkTGGg4gX97gIHhd5/iksjVZ4ABBjoXsb7T3ZusXVXkrlJpn/z55Z8///2Pf//4y6//+s//fPn+hz+//P23X75+/eXfP379zz9++v2X//z6/umfX574j8wv37fvvsjCMJ49tD30L9/3d5A9jD3oHuzL9/IOvoe5h4VBnz20PXQMNvage9gvt/1y2y+3/XLfL/f9ct8vd9nDjuI7iu8ovqP4juI7ytxR5o4y39eNd3j/pb7D3MPCsJ49tD30Pcgexh50D7aHN4q9w9zDwtCe54ztjP2McsZxRj2jndHPOM/4xvN3bM8Z2xn7GeWM44x6Rjujn3Ge8cTrJ14/8fqJ10+8fuL1E6+/8WaMfsZ5xrVHec7YztjPKGccZ9Qznnhy4smJJyfeOPHGiTdOvDj9VozjjHpGO6OfcZ5x7THOQoztjP2MJ56eeHri6YmnJ56eeHriWdTGE2iJnpDEG7O1gCYs4YmZWAdxwm+0RE9IIiN7RvaM7BnZM7Jn5JmRowxaD/SEJEZCE5bwxExE5LeeWhTNRkv0hCRGQhOW8MRMnMj9eRIt0ROSGImIPAKW8MRMrIOoqI2W6AlJjERGbhm5ZeSWkVtGjtpqGmiJnpDESGjCEp6YiXUgGVkysmRkyciSkSUjR601C3hiJtYBej3QEj0hiZHQREYeGXlk5JGRNSNrRo7aax6QxEhowhKemIl1gBoEWiIjW0a2jGwZ2TKyZWTU4AysA9Qg0BI9IYmR0IQlPJGRPSPPjDwz8szIMyOjBldAE5bwxEysA9Qg0BI9EZ/ZT2AkNGEJT8zE2pCowY2WEHyAyjPOqGe0M/oZ5xnXHqPmMLYz9jPGBsaFR9ufsNL0jHZGP+M84/6wlv6csZ2xn3F/YEsUTO+BlugJSYxE7BQJWMITMxE7JTY5CmajJXpCEiOhiYgcGxYFszET6yAKplugJXpCEhHZA5qwhCdmYh1EwWy0RESeAUmMhCYi8gp4YibWAa7S4szAdRrQE3GtFscWV2tAXK/FDscVG+CJmYjrttjhUR4Suy7KY2MkNGEJT8zEOoiqkNi9URUbkhgJTVjCExEw9nxURWBEVWy0RET2gCRGIiLPgCU8MRPrIKpkoyV64rz3EQUiK2AJT0TRPYF1EFUycAnfEj0hiSjluJSPD6QNS0Q1xwV9fCBtROTYjKivjZboiYijAUt4YibWQVTTiH0Y1bTRE5KILYydGdW0YQlPzMQ6iGraiMixD6OaNiQxEhE59mFU04YnZiJaT+zVqKaNlugJSYyEJiwRLS32fFTTxjqIatqIyHEIopo2JDESERk3X5bwRESOYxHVBMTHj8YOj4+fjZ6QRESOHY77o9h1uEMC1gHukoCW6AlJjERsWOzeqKaNmVgbGtW00RI9EQFXYCQ0YYm4bXoCM7EOopqsBVqiJyQxEpqwhCfOe9eoJuuBluiJCIi73JHQ/eGiUU0bnpgHUTs2Aj0hiZHQhCU8EW9ZA+sgqmmjJSKyBSQxEpqwhCdmIiLHe49q2miJnojIcbyimjY0YYmIHMcrqmljHUQ1bbRET0hiJDQRt7lxlKOaNmZiHUQ1eRzBqKaNnpBE3O7GsYhq2rBERI5DGdW0EZFjz0c1bbRET0Tk2PPx2eSxD6OaNmZiHUQ1bbRET0hiJCJg7PCopo2ZWBsW1bTREj0hiZGItzwDEWcF1gFmHYCW6AlJjIQmLBE39e8hsKiU2QI9IYmR0IQlPDET6wDTDUBGlowsGVkysmRkTDr0gCdmYh1g4gFoiZ6QxEhoIiOPjDwy8sjImpE1I2tGjtqZmA8bCU1YYibWQZTMHIGW6IkIqIGRiIAWsIQn5oGf89C8JSJgnCRRKRsjEQHjtIlK2YiAcdyjUjbWQVTKRkv0hCRGQhOWyMgzI0ftrDi1onY2WqInJDESmrCEJ2biRPbnSUTkFuiJiNwDI6EJS3hiJtZBlNVGS/RERm4ZOcpqYQbUEp6YiXUQn00bLdETkhiJjNwzcs/IPSP3jCwZWTJyVNwaAUmMhCYisgY8ca79PK/9HNd+QEtEQAuMhCbsABN5HugJSYyEJuJVM+CJmVgHUU1rBVqiJyQxEpqwRNyZP3G6YDpha6UwobCF+cI4iTClsCWlUYp7/ydOAEwrbHlpllYKUwtbrdRLyIGJ8VHSkpWQI44dphi2VgqTDFvIEUcL0wxbUkKOOE6Y7dtCjjgcmO/bmqV1NDHl98wQcqwQJjyfkJas5KVZWilM9G21EmZSW2iUtGQlL83SSmGibwuRewjx4iED5vFiQnBiIm9rpTCVt9VKvSSlUbKS537BRN4WIsdzDEzlbSGyhXpJSqOEyLHvMY+3NUsrham8rVbqJSnVMcI0XkxqTczjbSFybDNm8iBc/cVbs5boCUlgIjqiota2ZilixRzSRK3FhfVEXW2NEua14/igrra8NEuIF3lRV1ut1Esj8+4ZcwiR8WjJS7O0UqimmM+ZqKatXpJSbT2qactKXpqldbSep9RKcrZ+oa5iJmihrrashMgzNEtr99SFDzGgJXoCsVbISl7CJP8Twix/i8dsvSQlTOvH9mKOfMtKeGYgoVlaKVTXVs9sqKktRI73jznyLSshMp76zdJKobq2Wm7pqK0ftfWori0tWclLM6W1zaiumFJaqK4tOWf6wmT5lpashC2No4Dp8a1WQrw4jpghj/mihbra8hIeakQ81BWEutpqJTwyia1HrW2Nkpbw2CSOG2pta5ZWCrUWU0wLtRYTSQu1tiWlUdKSlbw0U/sRVbzz/YwKQuQ4lqi1rVHSUu2hVXtoP6qC1tH7AZ8b/RKx96NgIQeJ8A4amWXycpKriE+zQ8Sd4CCVNNLJSWLHI9h+aPWAQg4Sj5MaaKSTk8QDq47n3Q/ZyE4KOUgljXRyksw2mA3lGdNgLzsp5CCVNNLJSa4i6nTvPhTqIVLgJECpHippJFIoOMlVRBEf4g3txQKdFHKQShrp5CRXESV+yGzObM5szmzObCh0xamMSj+c5Cqi2A8b2Ulkw5mKgj9UEtmw11Hzh5NcRTSAw0Z2UshBKslsi9kWs63KhvUfSTz3fMBOCjlIJY10Es9XG7iKaAqHjUS2Dgo5SCWNdHKSq4hWcdhIZuvMhgYSM6ENS0mSRjqJbANcRTSQw0Z2UshBIpuCRjo5yVXcz8E3G9lJIQfJbIPZBrMNZhvMtp+NG9jITgo5SCWNdBLZ9nqgVUQvOUS2CXYS2XDSopccKmmkk5NcRfSSw0Z2ktmc2dBLHOc6esmhk5PESgCc6+glh1gNgLMPveRQyEEqaaSTk1xF9JJDZlvMhl7iOKvRSw6VNNLJSa7kXgNziGwD7KSQyKagkshmoJOTXEX0ksNGdlLIQSrJbI3Z0Et8rzlbRfSSw0YiG9aXoZccItsClTTSyUmuInrJYSM7KSSzCbOhl8ScdturaQ4nuYroJYeN7KSQg1SS2QazDWYbzKbMhl4SM95tr7U5FHKQShrp5CRXEb3kkNmM2dBLYnK77TU4h0oaiWw4wfdanM1V3OtxNhvZSSEHiWyoi702Z9PJSa7iXqOz2chOCjlIZpvMhl4yUYXoJYeriF5yiGyoFvSSQyEHiWyoFvSSQycnuZJYy5NsZCeFHKSSRjqJbHsl6Cqilxwi2wI7Gdlikr1h6U9SSSOx9qmBk1xF9JKYM29YD5TEKigBhRykkkY6OclVRC85bCSzCbOhl8SEeMMio6SRTk5yFdFLDhvZSSGZbTAbeklMwTcsPkpOchXRS2KavWERUrKTQg5SSSOdnOQqGrMZsxmzGbMZsxmzGbMZsxmzGbM5szmzObM5szmzoZcsnOvoJYdOTnIV0UsOG9lJIQfJbJPZ9j0OimHf42yu4nrIuueVJeQglTTSyUnWPe/YNzabjcQb2gu3hRykknhDC3QS8ykOrmJ7yEZiGeMDKmmkk5NcxY4ljQ3EosYODlJJxMXbxNqNw0muItYbxvORhhVRyU4KiWwKKmmkk8hmILJhP2AN4mEjOynkIJU00slJMpsymzKbMpsyG9YnPjjcWKF4aKSTk1xFrFU8bGQnRx1CLFU8RAqcUViueDjJVYxO0LFSHwutkp0UkqeG89RwI52c5CrOh+QpNzvJfTa5zyb32eQ+m9xnk/tscZ8t7rPFfbYXAm9GNnwbYGAx8KGRTk5yJbFkK9nITgo5SCWRrYNOIpuAq9gespGdFHKQShrpJLM1ZkN/iGdtDau8kp0UcpBKGunkJFdRmE2YTZhNmE2YTZhNmA1dIx7/NawMS64iusYhshnYyZpXxiqxpJJGIm7UPNaGJRvZSSEHiXeBYOgP8TywYV3YITrBIVZxP2AnhRwkVt7hPENTOHRykpGt4+xDUzhsZCeRDWcJmkLHXkdTODTSyUmuIprCYSM7KSSzTWabzDaZbTIb+kPH4UZ/OGxkJ4UcpJJGOrnyENpuCptIYWAnhRwkUjhopJOTrFPD2kM2spNCDlJJI52sfWb9IRvZSSEHqaSRTk4S2bDP9vcVNhvZSSEHqaSRTk6S2QazoRPgsRLWuyUjm+zvsg1SSSPxXQl8lQ2d4LCRnRRykEoa+U3cSa4i+kM8E25YCJfspJCDVNJIJ2fRmcKZwpnCmcKZwpnCmcKZwr9JsYpoCvEguGG5XLKTQg5SSSOdnOQqLmZbzLaYbTHbYjY0hXhe3rCYLunkJFcSi+qSjeykkINU0khkU3CSyBZtBQvtko3spJCDVNJIJyfJbJ3Z0Cpws4IFeEkhB6mkkU5OchXRKg6ZTZhNmE2YTZhNmE2YbX/VaYKriFZx2EhkW6CQdXvmQ0kj6/bM0SrGZiM7KeQglYy4A190RauIdQQN6/t6LCRoWMZ3/hSd4BDBcBqhExwa6eQkVxFN4bCRnRSS2ZzZnNmc2ZzZ0BQGzmo0BawcwPK+ZCeFHKSSRjo5yVVczLaYbTHbYrbFbGgKWMiA1X5JJye5kljxl2xkJ4VU0kikmOAkVxGd4BApFhgpMF+CFYHJQSpppJOTXEV0gsNGMltnts5sndk6s6ETYF0FFhImVxGd4LCRnRRykEoyhTCFMMVgisEUgykGUwymGEyxv/m4iWwdnOQqoikcNrKTQg5SSSOZTZlNmc2YzZjNmM2YDV0DU14TXePQSCeRLep4oj8cdlLIQSpppJPfxMW7iP6AVYrJRnZSyEEqaaSTTLGYYjHFYorFFIspFlMsplhMgaZwiGzRS7BwMdnITgo5SCWN9CI6AdaXYOVispNCDlJJI53Eu5jgKu5OsNnITgo5SCWNZIrOFMIUwhTCFMIUwhTCFMIUuxNsItsCV3F3gs1GdlLIQSpppJPMNphNmU2ZTZlNmU2ZTZkNnQBrZxY6weEkVxGd4LCRnRQysmGdzUInODTSSWTr4Cri+uGwkZ0UcpBKGukkszmzoT9gnQ2WViaRbYBCDlJJI52c5CqiVRw2ktkWs6FVYD0MllwmkQ0Vi1ZxOMl1+F5JPmQjOynkIJU00klkc3AV0UAOkW2CnRRykMi2QCOdxGzdjruK/SEbiUtsSEtW8tIsrRT6hW9GxFg107Eis8filY61lz3Wm3SsvUw6GVFjvUnH2stDdIbDRnZSyEEqaaSTzDaYTZlNmU2ZDZ0hlr/0Z/+2hE0ljXRykqu4f3PCZiM7yWzGbMZsxmzGbOgMjpMNnWETneGwkZ0UcpBKGukkszmzTWabzDaZDZ3Bcd6hMxwqaaSTk1xFdIbDRnaS2RazoTM4Cgmd4dDJSa4klmEmG9lJIQeppJFOTpLZGrM1ZmvM1pitMVtjtsZsjdnQGWL9UccyzEN0hsNGdlJIJY10kik6UwhTCFMIU+DSIhYdday9TCpppJOTXEU0kMNGMsVgisEUgykGUwymGEyhTKFMga5xiGwNHKSSRjo5yVVE1zhsZCeZzZjNmM2YzZjNmM2YDV0jFlR1LLhMdlJIZBPQyUmuIvrDYSM7KSTjoj/EGqiOpZVJJye5iugPh43spJBMsZgCTSEWVHWsp0yuJNZTJhvZSSEHqaSRTk6S2RqzNWZDU4iVXB3rKZODVBLZHHRykquIpnDYyE7mfFrHesqkkphVef7667sv+Qsif/z9t59/jt8P+c1vjPzhzy///em3n3/9/cv3v/7x9et3X/7XT1//wD/6n//+9CvG33/67f3bN+jPv/7zHd+A//rl68+hv77jq5//90vxhQq8+C3Gern+/78+7vj2663dvD4eZJ3X94vX41YBr+9X+dGT9uuXXrxeer5/GTfbL5r5Za6b18dqMrx+iF28fsRU7X79mhev1zr+erX/NRbqnNff7D+1PH/e56IXr7d6/++TuJvXP1avv9l/pvn+32dHN6+v4/8+zrh4vcejpv16u3q95+vf+d+L18+W+29e5Z+V/50Suqn/VfX73NRPPELLBvY+vrqJ8Dz5Ft4L6PbpCFfv4pGnIsj8bISrSnrvCBhB77bBtSJM+XSEq23Ar1XYEd77lrsIvSJc1dTHCHoVodd+aHfnA+YGd4R+Vdmt1UdzfEfoahsat6FfXd1g6caJcPX52rDaLbfh6liwRcWXD+4iPIwwPxlBnqvKkl77Qe6OhcS8XEbQz0aQm8pSjfvAc7lyV92D2zDu3sW3Ea7eRaxUrgjaPx3h6pwcxgh+tw2zqnvc1cU3EfS52gbt1Wm1X9WF1gVQLHP9dISrc1KF++HufLC6DIsFVVfbsOp8sLtjYcJtuPvM4s1ALLC7itCd23B1LLw9vJ682pMfrkhv9qS1uqmwd8bl5q5yPnlGjXl1VfwhQu9XEcQqwhifjrCuIigj2N021CfOy/XZCOtqG1YbNUlwdT05Vl0VvxHssxF6u4ogtR/W1fmgMmuyQy73pNZ0zfuk+yrC4ru4+tTTp2WXez/0rq6CHn8qgt8cTe11x6r9qstpr16t/eoKRPs3R/PqE0elroJe6lUEmYxgn41w9dmto67MX17VBa9I9e6a9kMEuTofxtCKcDcTOZwR7irrmwh6dZekWnes+p4QVxG07lD06r774z3O1bvgQ4X32vQmQqzJyGn5R662wev6Qe/m5T5EuLoCUa/rB/W7T5wPEdZVBE7Qu91tA88Hn+uzEa4+N99TsjrtvLoC0VnXD28E+2yEqysQnXUFondXpNaqV7+8i1D33dau7rt11jWMzqvq1mV1Tq6rbbCnur092q4i1DXMy6snL60+s95joZ+NcDcftWZ9bq6r55eGL3Xnvd7n7xavuj2+2rC7/TttfHPPO71mMOa6mj1YUnfNa9xFqGPR7o7FNxFiweVVBM4erDY/G6FffnbX0Xyunkl++PTvN++ia3W59+bgahvwS7Z3hHa1J3vj0oR3UuyqLurZQSw1+XQEu3oXdQUSi8M+HWF9uj9c3Xf3ulMb/eoTp/Muqd+ttOijHvW/7+fqnBxr1ln92GcjXN13d61Z1vdQfD6CXkWoWfc32PPpY3F1PmhdP7xsn+5RVzOcVp96w5+rM8pYWXb1yTueejo52tVs88Avoz4Rrq7lPka4ml1sdec+2ro6o8zrs9umfjbC3TZ4Xcu9vOq0Xnuy+9UajL60IryTnVcRambvjXC1H5ZXl1tL7iJwG67uWL+JIHfXcvLU0sj3kfu4ijC4uEnvItiqCFfXUdJqtlna1bWctLrflLvqFs5HvRH8sxGu7nml1RyItKvZRcEvFNoR+tWV+ccIV6tNO/fD+4FxFWHV+dDX3buoefs3wvhkBLmrTWFtyl1titZ+ELvbhm8jXNXFqHs9uZv5fx+ASEW4+ryQ4VxAva7OSa25ILmb8Rbl+XC39kCs7ljFru6SxGa9C7vrD1bXk2+wq23wWvX38uqM8np+IXfrkT9EuJr5F1evCHfnpNczlJfrsxHu+qTPqiy/q4tZ8w8yr+4vZI7ak/Py7sDqafXdLOvoXHvQr+71Ptz7X/VJ85qXs7unD0N4hyJ3dyhSd+5jPHff9BhPRbj6rsKHCHq1eoFPSN9N+HyEq5VFXHk47lYeDq25waFXKyiGeG2DzP7pCFf7QXlO6l11qzPC1Yz3txHsubr3t3qGMkzuZlHqmnbYVa/+OA9z8y7ej6x8F/4+0Lp6jjPri0x332Qzkepyd6tZTGo/2N05+SHC1XMcG/V5YaN/PsLV58Wo1U1vsKunk1xfbeOqNk1q5v8ti/bpCHf7YXI/XF3DmHIbVPSzEa7mq03rPsvu+qRpzUe9k6xX3zK0ut80k7sIdUVqdnWXZFYzGOaPfDrC1Z7kHYr5uPq+J+8O3vnWq3fx7dXg1buYUitJ5mVlcTWsrXa1DmTVU7mXN1eD7yddfWbdPee1xaO57s5qzrLaurqOsqXcD1fPcfypWXe/+/alP9Yrgj+fjjCuIijfxVWXeyu6tqFdPY3yVvcX3q6eHXhzbsPVdwYd/18ZO0K/us/y3vmV7Kse5fj9XCfCvItQ36ZxubsilZrReqdhro6FGCP4XQSeUeOq0zqf2vvduuKPEa7O6sHKGlefOB8j3O2HVe9Cr2YwPkTod/c4Ume1Xj2F+RDh6inMt/dZenVF6sb9YHcRJj8v5tXdwRT+0oS76wf3Xttwt7bZ+T21l1ed1tnt/a7be82Zvzv1qk/OXt1+Xt3z+pzVaefVd6t9sbqXXV1PPrWueD5X3yKZT913v5e0N9cP75lc29CurgZnq2+yzHZ1LCbXNs921SdnZ2XdzTbPXk+jZr86q2fnsfi/n5D+7f3pp3/88tuP3/yWqD//ili//fLT37/+fH781x+//uObv/39f/83/+bvv/3y9esv//7xv7/95x8///OP336OSPF3X57znx963Pf396nm37770uPn+K1W7x/29+eBn/v87v2fvD8r/v3blbvM9f5s8fPo778fNt+fHX+/nvfnbu/PE39v67uu4u/PK37W97h3Xc/7c/wirx90fKcRLH6V1w/vNYT1v/0Vb/3/AA==", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap index c1aef93ed98..8e531d3e5db 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_0.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2072 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2078 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2078 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2049 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2084 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2084 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2087 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2087 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2084 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2084 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2087 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2084 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2084 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 429 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 429 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 2045 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 417 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 422 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 428 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 429 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 434 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 440 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 446 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 452 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 458 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 467 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 473 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 491 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 497 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 504 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 512 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 518 }, Call { location: 2169 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 523 }, Call { location: 2084 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 531 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 534 }, Call { location: 2084 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 542 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2087 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 558 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 562 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 568 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 581 }, Jump { location: 572 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 623 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 614 }, Jump { location: 592 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 595 }, Jump { location: 604 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 604 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 607 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 613 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 623 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 623 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 626 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 632 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 640 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 659 }, Jump { location: 648 }, JumpIf { condition: Relative(29), location: 650 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 658 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 678 }, JumpIf { condition: Relative(29), location: 661 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 669 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 678 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 682 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 688 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 717 }, Jump { location: 709 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 716 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 733 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 724 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2172 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 733 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 740 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 748 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 780 }, Jump { location: 756 }, JumpIf { condition: Relative(29), location: 758 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 766 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 791 }, JumpIf { condition: Relative(29), location: 782 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 790 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 791 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 795 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 801 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 809 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 849 }, Jump { location: 821 }, JumpIf { condition: Relative(29), location: 823 }, Call { location: 2084 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 831 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 837 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1191 }, JumpIf { condition: Relative(29), location: 851 }, Call { location: 2084 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 859 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 872 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 884 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 897 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 903 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 906 }, Call { location: 2084 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 914 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 920 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 926 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2087 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 946 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2194 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 959 }, Call { location: 2084 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 966 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 972 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 978 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 984 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 990 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2194 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1003 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1009 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1015 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1021 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1027 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1033 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1048 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1054 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1060 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1066 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2286 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1078 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1084 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1090 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1094 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1097 }, Call { location: 2084 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2328 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1110 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1116 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1119 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1125 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1131 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1137 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1143 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1149 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1152 }, Call { location: 2084 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2397 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1170 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1178 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1184 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1190 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1191 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1199 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1205 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1211 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1219 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1270 }, Jump { location: 1230 }, JumpIf { condition: Relative(22), location: 1232 }, Call { location: 2084 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1240 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1258 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1290 }, JumpIf { condition: Relative(22), location: 1272 }, Call { location: 2084 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1280 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1290 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1298 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1304 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1310 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1318 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1324 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1341 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1347 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1353 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1361 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1412 }, Jump { location: 1372 }, JumpIf { condition: Relative(27), location: 1374 }, Call { location: 2084 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1382 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1400 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1432 }, JumpIf { condition: Relative(27), location: 1414 }, Call { location: 2084 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1422 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1432 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1440 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1446 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1452 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1460 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1464 }, Jump { location: 1484 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1472 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1484 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1492 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1507 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1513 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1519 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1527 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1533 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1550 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1556 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1562 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1570 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1627 }, Jump { location: 1585 }, JumpIf { condition: Relative(22), location: 1587 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1600 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1615 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1659 }, JumpIf { condition: Relative(22), location: 1629 }, Call { location: 2084 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1647 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1659 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1667 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1684 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1690 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1692 }, Jump { location: 1710 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1698 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1710 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1718 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1749 }, Jump { location: 1731 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1737 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1749 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1757 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1775 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1782 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1785 }, Call { location: 2084 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1793 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1799 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1807 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1813 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1821 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1827 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1836 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1843 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1943 }, Jump { location: 1853 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1856 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1869 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1884 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1899 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1905 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1911 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1926 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1934 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1940 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1961 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1949 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1961 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1969 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1986 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1992 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1994 }, Jump { location: 2012 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2000 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2012 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2027 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2033 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2044 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(1), location: 2049 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2057 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2077 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2091 }, Jump { location: 2093 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2112 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2110 }, 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: 2103 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2112 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2124 }, Jump { location: 2141 }, JumpIf { condition: Direct(32781), location: 2126 }, Jump { location: 2130 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2140 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2140 }, Jump { location: 2153 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2153 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2167 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2167 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2160 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2176 }, Jump { location: 2178 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2193 }, 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: 2190 }, 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: 2183 }, 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: 2193 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2205 }, Jump { location: 2222 }, JumpIf { condition: Direct(32781), location: 2207 }, Jump { location: 2211 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2221 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2221 }, Jump { location: 2234 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2234 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2247 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2240 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2258 }, Jump { location: 2262 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2284 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2283 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2276 }, Jump { location: 2284 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2296 }, Jump { location: 2304 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2327 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2326 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2319 }, Jump { location: 2327 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2339 }, Jump { location: 2356 }, JumpIf { condition: Direct(32782), location: 2341 }, Jump { location: 2345 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2355 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2355 }, Jump { location: 2368 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2368 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2382 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2382 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2375 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2396 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2389 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2406 }, Jump { location: 2412 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2434 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2433 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2426 }, Jump { location: 2434 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2449 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2442 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2073 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2079 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2079 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2050 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2085 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2088 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 434 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 434 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 427 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 433 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 434 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 439 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 445 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 451 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 457 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 463 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 472 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 478 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 496 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 502 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 509 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 517 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 523 }, Call { location: 2170 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 539 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 547 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2088 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 563 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 567 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 573 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 586 }, Jump { location: 577 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 619 }, Jump { location: 597 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 600 }, Jump { location: 609 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 609 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 612 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 618 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 628 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 631 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 637 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 645 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 664 }, Jump { location: 653 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 663 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 683 }, JumpIf { condition: Relative(29), location: 666 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 674 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 683 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 687 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 693 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 722 }, Jump { location: 714 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 721 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 738 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 729 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2173 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 738 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 745 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 753 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 785 }, Jump { location: 761 }, JumpIf { condition: Relative(29), location: 763 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 771 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 796 }, JumpIf { condition: Relative(29), location: 787 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 795 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 796 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 800 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 806 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 814 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 854 }, Jump { location: 826 }, JumpIf { condition: Relative(29), location: 828 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 836 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 842 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1196 }, JumpIf { condition: Relative(29), location: 856 }, Call { location: 2085 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 864 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 877 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 889 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 902 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 908 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 911 }, Call { location: 2085 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 919 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 925 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 931 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 951 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 964 }, Call { location: 2085 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 971 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 977 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 983 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 989 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 995 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1008 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1014 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1020 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1026 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1032 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1038 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1053 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1059 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1065 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1071 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2287 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1083 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1089 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1095 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1099 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1102 }, Call { location: 2085 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2329 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1115 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1121 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1124 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1130 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1136 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1142 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1148 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1154 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1157 }, Call { location: 2085 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2398 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1175 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1183 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1189 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1195 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1196 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1204 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1210 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1216 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1224 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1275 }, Jump { location: 1235 }, JumpIf { condition: Relative(22), location: 1237 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1245 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1263 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1295 }, JumpIf { condition: Relative(22), location: 1277 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1285 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1295 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1303 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1309 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1315 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1323 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1329 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1346 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1352 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1358 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1366 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1417 }, Jump { location: 1377 }, JumpIf { condition: Relative(27), location: 1379 }, Call { location: 2085 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1387 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1405 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1437 }, JumpIf { condition: Relative(27), location: 1419 }, Call { location: 2085 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1427 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1437 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1445 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1451 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1457 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1465 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1469 }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1477 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1497 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1512 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1518 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1524 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1532 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1538 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1555 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1561 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1567 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1575 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1632 }, Jump { location: 1590 }, JumpIf { condition: Relative(22), location: 1592 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1605 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1620 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1664 }, JumpIf { condition: Relative(22), location: 1634 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1652 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1664 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1672 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1689 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1695 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1697 }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1703 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1723 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1754 }, Jump { location: 1736 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1742 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1754 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1762 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1780 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1790 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1798 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1804 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1812 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1818 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1826 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1832 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1841 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1848 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1948 }, Jump { location: 1858 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1861 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1874 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1889 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1904 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1910 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1916 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1931 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1939 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1945 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1966 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1954 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1966 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1974 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1991 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1997 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1999 }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2005 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2032 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2038 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2049 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2058 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2078 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2092 }, Jump { location: 2094 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2113 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2111 }, 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: 2104 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2113 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2125 }, Jump { location: 2142 }, JumpIf { condition: Direct(32781), location: 2127 }, Jump { location: 2131 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2141 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2141 }, Jump { location: 2154 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2154 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2168 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2168 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2161 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2177 }, Jump { location: 2179 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2194 }, 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: 2191 }, 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: 2184 }, 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: 2194 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2206 }, Jump { location: 2223 }, JumpIf { condition: Direct(32781), location: 2208 }, Jump { location: 2212 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2222 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2222 }, Jump { location: 2235 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2235 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2248 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2241 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2259 }, Jump { location: 2263 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2285 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2284 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2277 }, Jump { location: 2285 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2297 }, Jump { location: 2305 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2328 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2327 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2320 }, Jump { location: 2328 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2340 }, Jump { location: 2357 }, JumpIf { condition: Direct(32782), location: 2342 }, Jump { location: 2346 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2356 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2356 }, Jump { location: 2369 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2369 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2383 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2383 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2376 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2397 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2390 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2407 }, Jump { location: 2413 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2435 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2434 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2427 }, Jump { location: 2435 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2450 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2443 }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index c1aef93ed98..8e531d3e5db 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/slice_dynamic_index/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -49,9 +49,9 @@ expression: artifact "return value indices : []", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: []", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2072 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2078 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2078 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2049 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2084 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2084 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2087 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2087 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2084 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2084 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2087 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2084 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2084 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 429 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 429 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 2045 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 417 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 422 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 428 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 429 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 434 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 440 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 446 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 452 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 458 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 467 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 473 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 491 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 497 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 504 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 512 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 518 }, Call { location: 2169 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 523 }, Call { location: 2084 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 531 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 534 }, Call { location: 2084 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 542 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2087 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 558 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 562 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 568 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 581 }, Jump { location: 572 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 623 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2087 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 614 }, Jump { location: 592 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 595 }, Jump { location: 604 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 604 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 607 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 613 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 623 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 623 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 626 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 632 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 640 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 659 }, Jump { location: 648 }, JumpIf { condition: Relative(29), location: 650 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 658 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 678 }, JumpIf { condition: Relative(29), location: 661 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 669 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 678 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 682 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 688 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 717 }, Jump { location: 709 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 716 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 733 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 724 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2172 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 733 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 740 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 748 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 780 }, Jump { location: 756 }, JumpIf { condition: Relative(29), location: 758 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 766 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2087 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 791 }, JumpIf { condition: Relative(29), location: 782 }, Call { location: 2084 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 790 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 791 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 795 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 801 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 809 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 849 }, Jump { location: 821 }, JumpIf { condition: Relative(29), location: 823 }, Call { location: 2084 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 831 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 837 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1191 }, JumpIf { condition: Relative(29), location: 851 }, Call { location: 2084 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 859 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2087 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 872 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 884 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 897 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 903 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 906 }, Call { location: 2084 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 914 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 920 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 926 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2087 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 946 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2194 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 959 }, Call { location: 2084 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 966 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 972 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 978 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 984 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 990 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2194 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1003 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1009 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1015 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1021 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1027 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1033 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1048 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1054 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1060 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1066 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2286 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1078 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1084 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1090 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1094 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1097 }, Call { location: 2084 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2328 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1110 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1116 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1119 }, Call { location: 2084 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1125 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1131 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1137 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1143 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1149 }, Call { location: 2078 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1152 }, Call { location: 2084 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2397 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1170 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1178 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1184 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1190 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1191 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1199 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1205 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1211 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1219 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1270 }, Jump { location: 1230 }, JumpIf { condition: Relative(22), location: 1232 }, Call { location: 2084 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1240 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1258 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1290 }, JumpIf { condition: Relative(22), location: 1272 }, Call { location: 2084 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1280 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1290 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1298 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1304 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1310 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1318 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1324 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1341 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1347 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1353 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1361 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1412 }, Jump { location: 1372 }, JumpIf { condition: Relative(27), location: 1374 }, Call { location: 2084 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1382 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1400 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1432 }, JumpIf { condition: Relative(27), location: 1414 }, Call { location: 2084 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1422 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2087 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1432 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1440 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1446 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1452 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1460 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1464 }, Jump { location: 1484 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1472 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1484 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1492 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1507 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1513 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1519 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1527 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1533 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1550 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1556 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1562 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1570 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1627 }, Jump { location: 1585 }, JumpIf { condition: Relative(22), location: 1587 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1600 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1615 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1659 }, JumpIf { condition: Relative(22), location: 1629 }, Call { location: 2084 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1647 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1659 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1667 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1684 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1690 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1692 }, Jump { location: 1710 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1698 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1710 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1718 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1749 }, Jump { location: 1731 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1737 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1749 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1757 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1775 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1782 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1785 }, Call { location: 2084 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1793 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1799 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1807 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1813 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1821 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1827 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1836 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1843 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1943 }, Jump { location: 1853 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1856 }, Call { location: 2084 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2087 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1869 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1884 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1899 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1905 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1911 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1926 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1934 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1940 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1961 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1949 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1961 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1969 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1986 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1992 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1994 }, Jump { location: 2012 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2000 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2012 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2027 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2033 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2249 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2044 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(1), location: 2049 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(2) } }, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2057 }, Call { location: 2081 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2113 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2077 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2091 }, Jump { location: 2093 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2112 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2110 }, 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: 2103 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2112 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2124 }, Jump { location: 2141 }, JumpIf { condition: Direct(32781), location: 2126 }, Jump { location: 2130 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2140 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2140 }, Jump { location: 2153 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2153 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2167 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2167 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2160 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2176 }, Jump { location: 2178 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2193 }, 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: 2190 }, 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: 2183 }, 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: 2193 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2205 }, Jump { location: 2222 }, JumpIf { condition: Direct(32781), location: 2207 }, Jump { location: 2211 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2221 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2221 }, Jump { location: 2234 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2234 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2247 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2240 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2258 }, Jump { location: 2262 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2284 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2283 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2276 }, Jump { location: 2284 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2296 }, Jump { location: 2304 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2327 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2326 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2319 }, Jump { location: 2327 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2339 }, Jump { location: 2356 }, JumpIf { condition: Direct(32782), location: 2341 }, Jump { location: 2345 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2355 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2355 }, Jump { location: 2368 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2368 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2382 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2382 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2375 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2396 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2389 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2406 }, Jump { location: 2412 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2434 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2433 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2426 }, Jump { location: 2434 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2449 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2442 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Cast { destination: Direct(32836), source: Direct(32836), bit_size: Integer(U32) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 13 }, Call { location: 14 }, Const { destination: Relative(1), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, Stop { return_data: HeapVector { pointer: Relative(1), size: Relative(2) } }, Return, Call { location: 2073 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(4), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(3) }, BinaryIntOp { destination: Relative(5), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 20 }, Call { location: 2079 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 4 }, BinaryIntOp { destination: Relative(6), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Relative(5) }, BinaryIntOp { destination: Relative(7), op: LessThanEquals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, JumpIf { condition: Relative(7), location: 25 }, Call { location: 2079 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(9) }, Mov { destination: Relative(1), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(8) }, IndirectConst { destination_pointer: Relative(1), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(7) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(1), rhs: Relative(8) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, Store { destination_pointer: Relative(7), source: Relative(8) }, Mov { destination: Relative(9), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 5 }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 47 }, BinaryIntOp { destination: Relative(10), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(10), location: 2050 }, Jump { location: 50 }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Load { destination: Relative(11), source_pointer: Relative(10) }, Const { destination: Relative(12), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(12), rhs: Relative(11) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 58 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 64 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(2), source_pointer: Relative(10) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 70 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(10), 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) }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Const { destination: Relative(14), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(13), location: 78 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(15), bit_size: Field, value: 4 }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(13), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 87 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, BinaryIntOp { destination: Relative(13), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(1) }, JumpIf { condition: Relative(13), location: 90 }, Call { location: 2085 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(10), rhs: Relative(17) }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(6) }, Load { destination: Relative(13), source_pointer: Relative(17) }, Const { destination: Relative(16), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(13), rhs: Relative(16) }, JumpIf { condition: Relative(17), location: 99 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Mov { destination: Direct(32771), source: Relative(10) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(6) }, Store { destination_pointer: Relative(19), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Const { destination: Relative(19), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(19) }, BinaryIntOp { destination: Relative(19), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Load { destination: Relative(10), source_pointer: Relative(19) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(15) }, JumpIf { condition: Relative(18), location: 116 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(5) }, Load { destination: Relative(10), source_pointer: Relative(18) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(10), rhs: Relative(13) }, JumpIf { condition: Relative(18), location: 122 }, Const { destination: Relative(19), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(19) } }, Const { destination: Relative(10), bit_size: Integer(U32), value: 10 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(10) }, Const { destination: Relative(19), bit_size: Field, value: 2 }, JumpIf { condition: Relative(18), location: 136 }, Jump { location: 127 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Store { destination_pointer: Relative(2), source: Relative(11) }, Jump { location: 159 }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(11), source: Direct(32772) }, Const { destination: Relative(20), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(20) }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(12), rhs: Relative(4) }, Store { destination_pointer: Relative(20), source: Relative(19) }, BinaryIntOp { destination: Relative(12), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(17), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 147 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(12), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 150 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(11) }, Call { location: 2088 }, Mov { destination: Relative(17), source: Direct(32772) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(12) }, Store { destination_pointer: Relative(21), source: Relative(19) }, Store { destination_pointer: Relative(2), source: Relative(17) }, Jump { location: 159 }, Load { destination: Relative(11), source_pointer: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Load { destination: Relative(12), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(17), op: Equals, lhs: Relative(12), rhs: Relative(19) }, JumpIf { condition: Relative(17), location: 167 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Const { destination: Relative(12), bit_size: Integer(U32), value: 7 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(12) }, Load { destination: Relative(17), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(17), rhs: Relative(19) }, JumpIf { condition: Relative(11), location: 174 }, Const { destination: Relative(20), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(20) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(17), source_pointer: Relative(9) }, Load { destination: Relative(20), source_pointer: Relative(17) }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(21), rhs: Relative(20) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 182 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(20), rhs: Direct(2) }, Store { destination_pointer: Relative(17), source: Relative(20) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 189 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 197 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(22), location: 200 }, Call { location: 2085 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(17), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Load { destination: Relative(22), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(22), rhs: Relative(16) }, JumpIf { condition: Relative(23), location: 208 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Mov { destination: Direct(32771), source: Relative(17) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(6) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Load { destination: Relative(17), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(15) }, JumpIf { condition: Relative(23), location: 224 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(17), location: 227 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(5) }, Load { destination: Relative(17), source_pointer: Relative(23) }, BinaryFieldOp { destination: Relative(23), op: Equals, lhs: Relative(17), rhs: Relative(13) }, JumpIf { condition: Relative(23), location: 233 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, BinaryIntOp { destination: Relative(17), op: LessThan, bit_size: U32, lhs: Relative(10), rhs: Relative(4) }, JumpIf { condition: Relative(17), location: 245 }, Jump { location: 236 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(13) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Jump { location: 268 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(21), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(23), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(19) }, BinaryIntOp { destination: Relative(22), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(23), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(23), location: 256 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(23), op: LessThan, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, JumpIf { condition: Relative(23), location: 259 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(21) }, Call { location: 2088 }, Mov { destination: Relative(23), source: Direct(32772) }, Const { destination: Relative(25), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(23), rhs: Relative(25) }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(22) }, Store { destination_pointer: Relative(25), source: Relative(19) }, Store { destination_pointer: Relative(20), source: Relative(23) }, Jump { location: 268 }, Load { destination: Relative(21), source_pointer: Relative(20) }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 272 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(20), op: Add, bit_size: U32, lhs: Relative(21), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(20) }, BinaryFieldOp { destination: Relative(20), op: Equals, lhs: Relative(11), rhs: Relative(13) }, JumpIf { condition: Relative(20), location: 278 }, Const { destination: Relative(21), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(21) } }, Load { destination: Relative(11), source_pointer: Relative(7) }, Load { destination: Relative(20), source_pointer: Relative(9) }, Load { destination: Relative(21), source_pointer: Relative(20) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 286 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(21) }, Mov { destination: Relative(21), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Mov { destination: Relative(23), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 295 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 303 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(6), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 306 }, Call { location: 2085 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(20), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(24), rhs: Relative(16) }, JumpIf { condition: Relative(25), location: 314 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Mov { destination: Direct(32771), source: Relative(20) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(6) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(25), rhs: Relative(4) }, Load { destination: Relative(20), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(15) }, JumpIf { condition: Relative(25), location: 331 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, BinaryIntOp { destination: Relative(20), op: LessThan, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, JumpIf { condition: Relative(20), location: 334 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(25), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(5) }, Load { destination: Relative(20), source_pointer: Relative(25) }, BinaryFieldOp { destination: Relative(25), op: Equals, lhs: Relative(20), rhs: Relative(13) }, JumpIf { condition: Relative(25), location: 340 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(20), bit_size: Field, value: 10 }, Const { destination: Relative(25), bit_size: Field, value: 15 }, Const { destination: Relative(26), bit_size: Field, value: 22 }, JumpIf { condition: Relative(18), location: 355 }, Jump { location: 345 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(13) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, Jump { location: 434 }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(19) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 377 }, Jump { location: 367 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(26) }, Store { destination_pointer: Relative(21), source: Relative(11) }, Store { destination_pointer: Relative(23), source: Relative(24) }, Jump { location: 434 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(24), location: 417 }, Jump { location: 380 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(28), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(28) }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(28), source: Relative(20) }, Load { destination: Relative(22), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(22) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 393 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(28), source: Direct(32773) }, Mov { destination: Relative(29), source: Direct(32774) }, Store { destination_pointer: Relative(29), source: Relative(25) }, Store { destination_pointer: Relative(21), source: Relative(22) }, Store { destination_pointer: Relative(23), source: Relative(28) }, Load { destination: Relative(11), source_pointer: Relative(28) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 410 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(28), source: Relative(11) }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(11), location: 416 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Jump { location: 422 }, BinaryFieldOp { destination: Relative(11), op: Equals, lhs: Relative(19), rhs: Relative(26) }, JumpIf { condition: Relative(11), location: 421 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Jump { location: 422 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 427 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(11), source_pointer: Relative(24) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(11), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 433 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Jump { location: 434 }, Load { destination: Relative(11), source_pointer: Relative(21) }, Load { destination: Relative(22), source_pointer: Relative(23) }, BinaryIntOp { destination: Relative(24), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(24), location: 439 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(27) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(24), rhs: Relative(20) }, JumpIf { condition: Relative(27), location: 445 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(24) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 451 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, JumpIf { condition: Relative(24), location: 457 }, Const { destination: Relative(28), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(28) } }, Load { destination: Relative(11), source_pointer: Relative(22) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(28), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(11) }, Not { destination: Relative(28), source: Relative(28), bit_size: U1 }, JumpIf { condition: Relative(28), location: 463 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(11) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 8 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(11) }, Load { destination: Relative(28), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(28), rhs: Relative(25) }, JumpIf { condition: Relative(29), location: 472 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(28), source_pointer: Relative(22) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(28) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 478 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(28), op: Add, bit_size: U32, lhs: Relative(28), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(28) }, Const { destination: Relative(28), bit_size: Field, value: 20 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(31), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(28) }, Store { destination_pointer: Relative(21), source: Relative(30) }, Store { destination_pointer: Relative(23), source: Relative(31) }, Load { destination: Relative(21), source_pointer: Relative(31) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(23), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(21) }, Not { destination: Relative(23), source: Relative(23), bit_size: U1 }, JumpIf { condition: Relative(23), location: 496 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(21), op: Add, bit_size: U32, lhs: Relative(21), rhs: Direct(2) }, Store { destination_pointer: Relative(31), source: Relative(21) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(30), rhs: Relative(12) }, JumpIf { condition: Relative(21), location: 502 }, Const { destination: Relative(23), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(23) } }, Const { destination: Relative(21), bit_size: Integer(U32), value: 9 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(21) }, Load { destination: Relative(23), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(30), op: Equals, lhs: Relative(23), rhs: Relative(28) }, JumpIf { condition: Relative(30), location: 509 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Load { destination: Relative(23), source_pointer: Relative(7) }, Load { destination: Relative(30), source_pointer: Relative(9) }, Load { destination: Relative(31), source_pointer: Relative(30) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(31) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 517 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(31), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(3) }, BinaryIntOp { destination: Relative(33), op: LessThanEquals, bit_size: U32, lhs: Relative(6), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 523 }, Call { location: 2170 }, Mov { destination: Relative(33), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 528 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 536 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(31), rhs: Relative(23) }, JumpIf { condition: Relative(34), location: 539 }, Call { location: 2085 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(30), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Load { destination: Relative(34), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(34), rhs: Relative(19) }, JumpIf { condition: Relative(35), location: 547 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Mov { destination: Direct(32771), source: Relative(30) }, Call { location: 2088 }, Mov { destination: Relative(34), source: Direct(32772) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(31) }, Store { destination_pointer: Relative(36), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(34) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(35), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(36) }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(35), rhs: Relative(4) }, Load { destination: Relative(30), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(35), op: Equals, lhs: Relative(30), rhs: Relative(15) }, JumpIf { condition: Relative(35), location: 563 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Const { destination: Relative(30), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(23) }, JumpIf { condition: Relative(35), location: 567 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(1) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(13) }, JumpIf { condition: Relative(36), location: 573 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(35), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(23) }, Const { destination: Relative(23), bit_size: Field, value: 5 }, JumpIf { condition: Relative(18), location: 586 }, Jump { location: 577 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(26) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Store { destination_pointer: Relative(33), source: Relative(22) }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(34) }, Call { location: 2088 }, Mov { destination: Relative(22), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(19) }, Store { destination_pointer: Relative(33), source: Relative(22) }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(31), rhs: Relative(3) }, JumpIf { condition: Relative(24), location: 619 }, Jump { location: 597 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, JumpIf { condition: Relative(24), location: 600 }, Jump { location: 609 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(27) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(27), source: Relative(23) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 609 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 612 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 618 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Jump { location: 628 }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(24), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(26) }, Store { destination_pointer: Relative(33), source: Relative(24) }, Jump { location: 628 }, Load { destination: Relative(22), source_pointer: Relative(33) }, JumpIf { condition: Relative(35), location: 631 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(12) }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(24), rhs: Relative(23) }, JumpIf { condition: Relative(22), location: 637 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 645 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(18), location: 664 }, Jump { location: 653 }, JumpIf { condition: Relative(29), location: 655 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 663 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 683 }, JumpIf { condition: Relative(29), location: 666 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 674 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Store { destination_pointer: Relative(31), source: Relative(19) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 683 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 687 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 693 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Const { destination: Relative(22), bit_size: Field, value: 3 }, Mov { destination: Relative(24), source: Direct(1) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 6 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(26) }, IndirectConst { destination_pointer: Relative(24), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Mov { destination: Relative(27), source: Relative(26) }, Store { destination_pointer: Relative(27), source: Relative(13) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(16) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(19) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(27), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(15) }, Mov { destination: Relative(22), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, JumpIf { condition: Relative(18), location: 722 }, Jump { location: 714 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(26), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 721 }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(27) } }, Jump { location: 738 }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Load { destination: Relative(26), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(27), op: Equals, lhs: Relative(26), rhs: Relative(15) }, JumpIf { condition: Relative(27), location: 729 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(24) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 6 }, Call { location: 2173 }, Mov { destination: Relative(26), source: Direct(32773) }, BinaryIntOp { destination: Relative(27), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Store { destination_pointer: Relative(22), source: Relative(26) }, Jump { location: 738 }, Load { destination: Relative(24), source_pointer: Relative(22) }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(1) }, Load { destination: Relative(22), source_pointer: Relative(26) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(22), rhs: Relative(19) }, JumpIf { condition: Relative(24), location: 745 }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(26) } }, Load { destination: Relative(22), source_pointer: Relative(7) }, Load { destination: Relative(24), source_pointer: Relative(9) }, Load { destination: Relative(26), source_pointer: Relative(24) }, Const { destination: Relative(27), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(27), rhs: Relative(26) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 753 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(26), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(26) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(24) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(17), location: 785 }, Jump { location: 761 }, JumpIf { condition: Relative(29), location: 763 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Equals, lhs: Relative(27), rhs: Relative(15) }, JumpIf { condition: Relative(29), location: 771 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(31) } }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(29), op: Sub, lhs: Relative(27), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(24) }, Call { location: 2088 }, Mov { destination: Relative(27), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(27), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(31), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(29) }, Store { destination_pointer: Relative(26), source: Relative(27) }, Jump { location: 796 }, JumpIf { condition: Relative(29), location: 787 }, Call { location: 2085 }, Const { destination: Relative(31), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(31) }, BinaryIntOp { destination: Relative(31), op: Add, bit_size: U32, lhs: Relative(29), rhs: Relative(4) }, Load { destination: Relative(27), source_pointer: Relative(31) }, BinaryFieldOp { destination: Relative(24), op: Equals, lhs: Relative(27), rhs: Relative(13) }, JumpIf { condition: Relative(24), location: 795 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Jump { location: 796 }, Load { destination: Relative(24), source_pointer: Relative(26) }, BinaryIntOp { destination: Relative(26), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(22) }, JumpIf { condition: Relative(26), location: 800 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(12) }, Load { destination: Relative(5), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(5), rhs: Relative(19) }, JumpIf { condition: Relative(22), location: 806 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(22), source_pointer: Relative(9) }, Load { destination: Relative(24), source_pointer: Relative(22) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(27), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(24) }, Not { destination: Relative(27), source: Relative(27), bit_size: U1 }, JumpIf { condition: Relative(27), location: 814 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(24), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(24) }, Mov { destination: Relative(24), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(5) }, Mov { destination: Relative(27), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(27), source: Relative(22) }, BinaryIntOp { destination: Relative(29), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(31), bit_size: Field, value: 30 }, JumpIf { condition: Relative(18), location: 854 }, Jump { location: 826 }, JumpIf { condition: Relative(29), location: 828 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, Load { destination: Relative(1), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(13) }, JumpIf { condition: Relative(3), location: 836 }, 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(22) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 842 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(22), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(22) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(28) }, Store { destination_pointer: Relative(24), source: Relative(1) }, Store { destination_pointer: Relative(27), source: Relative(8) }, Jump { location: 1196 }, JumpIf { condition: Relative(29), location: 856 }, Call { location: 2085 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Load { destination: Relative(18), source_pointer: Relative(29) }, BinaryFieldOp { destination: Relative(26), op: Equals, lhs: Relative(18), rhs: Relative(15) }, JumpIf { condition: Relative(26), location: 864 }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(29) } }, Mov { destination: Direct(32771), source: Relative(22) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(26), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(29) }, BinaryIntOp { destination: Relative(29), op: Add, bit_size: U32, lhs: Relative(26), rhs: Relative(4) }, Store { destination_pointer: Relative(29), source: Relative(19) }, Load { destination: Relative(22), source_pointer: Relative(18) }, Const { destination: Relative(26), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(29), op: Equals, bit_size: U32, lhs: Relative(26), rhs: Relative(22) }, Not { destination: Relative(29), source: Relative(29), bit_size: U1 }, JumpIf { condition: Relative(29), location: 877 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(22), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(18) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(29), source: Direct(32773) }, Mov { destination: Relative(32), source: Direct(32774) }, Store { destination_pointer: Relative(32), source: Relative(20) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(22) }, JumpIf { condition: Relative(5), location: 889 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(29) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(32) }, BinaryIntOp { destination: Relative(32), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(4) }, Store { destination_pointer: Relative(32), source: Relative(20) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(29), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(32), op: Equals, bit_size: U32, lhs: Relative(29), rhs: Relative(18) }, Not { destination: Relative(32), source: Relative(32), bit_size: U1 }, JumpIf { condition: Relative(32), location: 902 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Sub, bit_size: U32, lhs: Relative(22), rhs: Relative(3) }, BinaryIntOp { destination: Relative(32), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 908 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(32), op: LessThan, bit_size: U32, lhs: Relative(18), rhs: Relative(22) }, JumpIf { condition: Relative(32), location: 911 }, Call { location: 2085 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(34) }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Load { destination: Relative(32), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(18), op: Equals, lhs: Relative(32), rhs: Relative(20) }, JumpIf { condition: Relative(18), location: 919 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(32), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(32), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 925 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 931 }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(33) } }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(18), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(18), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(28) }, Mov { destination: Direct(32771), source: Relative(18) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(33) }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(33), source: Relative(31) }, Load { destination: Relative(18), source_pointer: Relative(5) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(33), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(18) }, Not { destination: Relative(33), source: Relative(33), bit_size: U1 }, JumpIf { condition: Relative(33), location: 951 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 11 }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(34), source: Direct(32773) }, Mov { destination: Relative(35), source: Direct(32774) }, Store { destination_pointer: Relative(35), source: Relative(18) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(33) }, JumpIf { condition: Relative(5), location: 964 }, Call { location: 2085 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Load { destination: Relative(35), source_pointer: Relative(36) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(35), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 971 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(35), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(35), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 977 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 983 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, BinaryIntOp { destination: Relative(33), op: Add, bit_size: U32, lhs: Relative(34), rhs: Relative(11) }, Load { destination: Relative(18), source_pointer: Relative(33) }, BinaryFieldOp { destination: Relative(33), op: Equals, lhs: Relative(18), rhs: Relative(31) }, JumpIf { condition: Relative(33), location: 989 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(18), source_pointer: Relative(34) }, Const { destination: Relative(33), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(33), rhs: Relative(18) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 995 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(34), source: Relative(18) }, Const { destination: Relative(18), bit_size: Field, value: 12 }, BinaryIntOp { destination: Relative(36), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(34) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2195 }, Mov { destination: Relative(37), source: Direct(32773) }, Mov { destination: Relative(38), source: Direct(32774) }, Store { destination_pointer: Relative(38), source: Relative(18) }, BinaryIntOp { destination: Relative(34), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(36) }, JumpIf { condition: Relative(34), location: 1008 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(5) }, Load { destination: Relative(8), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(8), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1014 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(34), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(34), source: Relative(34), bit_size: U1 }, JumpIf { condition: Relative(34), location: 1020 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(11) }, JumpIf { condition: Relative(5), location: 1026 }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(34) } }, BinaryIntOp { destination: Relative(34), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(5), source_pointer: Relative(34) }, BinaryFieldOp { destination: Relative(34), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(34), location: 1032 }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(36) } }, Load { destination: Relative(5), source_pointer: Relative(37) }, Const { destination: Relative(34), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(36), op: Equals, bit_size: U32, lhs: Relative(34), rhs: Relative(5) }, Not { destination: Relative(36), source: Relative(36), bit_size: U1 }, JumpIf { condition: Relative(36), location: 1038 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(37) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(36), source: Direct(32773) }, Mov { destination: Relative(39), source: Direct(32774) }, Load { destination: Relative(38), source_pointer: Relative(39) }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(39), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(39), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1053 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryFieldOp { destination: Relative(37), op: Equals, lhs: Relative(38), rhs: Relative(20) }, JumpIf { condition: Relative(37), location: 1059 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(37), source_pointer: Relative(36) }, Const { destination: Relative(38), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(38), rhs: Relative(37) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1065 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(37), op: Add, bit_size: U32, lhs: Relative(37), rhs: Direct(2) }, Store { destination_pointer: Relative(36), source: Relative(37) }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(37), location: 1071 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(42), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(41), op: Add, bit_size: U32, lhs: Relative(36), rhs: Relative(42) }, Load { destination: Relative(37), source_pointer: Relative(41) }, Mov { destination: Direct(32771), source: Relative(36) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2287 }, Mov { destination: Relative(40), source: Direct(32773) }, BinaryFieldOp { destination: Relative(36), op: Equals, lhs: Relative(37), rhs: Relative(18) }, JumpIf { condition: Relative(36), location: 1083 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(41) } }, Load { destination: Relative(18), source_pointer: Relative(40) }, Const { destination: Relative(36), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(37), op: Equals, bit_size: U32, lhs: Relative(36), rhs: Relative(18) }, Not { destination: Relative(37), source: Relative(37), bit_size: U1 }, JumpIf { condition: Relative(37), location: 1089 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(40), source: Relative(18) }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(2) }, JumpIf { condition: Relative(18), location: 1095 }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(37) } }, BinaryIntOp { destination: Relative(5), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(30) }, BinaryIntOp { destination: Relative(18), op: LessThanEquals, bit_size: U32, lhs: Relative(30), rhs: Relative(4) }, JumpIf { condition: Relative(18), location: 1099 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(18), op: LessThan, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(18), location: 1102 }, Call { location: 2085 }, Const { destination: Relative(41), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(41), op: Mul, bit_size: U32, lhs: Relative(41), rhs: Relative(5) }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(40) }, Mov { destination: Direct(32772), source: Relative(41) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2329 }, Mov { destination: Relative(37), source: Direct(32774) }, Mov { destination: Relative(42), source: Direct(32775) }, Store { destination_pointer: Relative(42), source: Relative(28) }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(30), rhs: Relative(18) }, JumpIf { condition: Relative(5), location: 1115 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(30), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Load { destination: Relative(5), source_pointer: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(28) }, JumpIf { condition: Relative(1), location: 1121 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, BinaryIntOp { destination: Relative(1), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(18) }, JumpIf { condition: Relative(1), location: 1124 }, Call { location: 2085 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(5), location: 1130 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1136 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1142 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Load { destination: Relative(1), source_pointer: Relative(37) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(30), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(1) }, Not { destination: Relative(30), source: Relative(30), bit_size: U1 }, JumpIf { condition: Relative(30), location: 1148 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(37), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, BinaryIntOp { destination: Relative(30), op: LessThanEquals, bit_size: U32, lhs: Relative(3), rhs: Relative(4) }, JumpIf { condition: Relative(30), location: 1154 }, Call { location: 2079 }, BinaryIntOp { destination: Relative(3), op: LessThan, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1157 }, Call { location: 2085 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(40), op: Mul, bit_size: U32, lhs: Relative(40), rhs: Relative(1) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Const { destination: Relative(43), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(37), rhs: Relative(43) }, BinaryIntOp { destination: Relative(42), op: Add, bit_size: U32, lhs: Relative(42), rhs: Relative(40) }, Load { destination: Relative(41), source_pointer: Relative(42) }, Mov { destination: Direct(32771), source: Relative(37) }, Mov { destination: Direct(32772), source: Relative(40) }, Const { destination: Direct(32773), bit_size: Integer(U32), value: 1 }, Call { location: 2398 }, Mov { destination: Relative(30), source: Direct(32774) }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(37), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(37), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1175 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, Store { destination_pointer: Relative(24), source: Relative(3) }, Store { destination_pointer: Relative(27), source: Relative(30) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(41), rhs: Relative(16) }, JumpIf { condition: Relative(1), location: 1183 }, Const { destination: Relative(40), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(40) } }, Load { destination: Relative(1), source_pointer: Relative(30) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(40), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(1) }, Not { destination: Relative(40), source: Relative(40), bit_size: U1 }, JumpIf { condition: Relative(40), location: 1189 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(30), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(3), rhs: Relative(2) }, JumpIf { condition: Relative(1), location: 1195 }, Const { destination: Relative(30), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(30) } }, Jump { location: 1196 }, Load { destination: Relative(1), source_pointer: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(27) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1204 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1210 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(31) }, JumpIf { condition: Relative(3), location: 1216 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(5) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1224 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(5), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(3) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1275 }, Jump { location: 1235 }, JumpIf { condition: Relative(22), location: 1237 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(15) }, JumpIf { condition: Relative(16), location: 1245 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Sub, lhs: Relative(8), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(24) }, BinaryIntOp { destination: Relative(24), op: Add, bit_size: U32, lhs: Relative(22), rhs: Relative(4) }, Store { destination_pointer: Relative(24), source: Relative(16) }, Load { destination: Relative(3), source_pointer: Relative(8) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(3) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1263 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(22), source: Direct(32773) }, Mov { destination: Relative(24), source: Direct(32774) }, Store { destination_pointer: Relative(24), source: Relative(20) }, Store { destination_pointer: Relative(5), source: Relative(3) }, Store { destination_pointer: Relative(18), source: Relative(22) }, Jump { location: 1295 }, JumpIf { condition: Relative(22), location: 1277 }, Call { location: 2085 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Load { destination: Relative(8), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(16), op: Equals, lhs: Relative(8), rhs: Relative(13) }, JumpIf { condition: Relative(16), location: 1285 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(8), source: Direct(32772) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(22) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(4) }, Store { destination_pointer: Relative(22), source: Relative(19) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(8) }, Jump { location: 1295 }, Load { destination: Relative(1), source_pointer: Relative(5) }, Load { destination: Relative(3), source_pointer: Relative(18) }, Load { destination: Relative(8), source_pointer: Relative(3) }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(16), rhs: Relative(8) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1303 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(8), location: 1309 }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(22) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(22), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(1) }, Not { destination: Relative(22), source: Relative(22), bit_size: U1 }, JumpIf { condition: Relative(22), location: 1315 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(22), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(22) }, BinaryFieldOp { destination: Relative(22), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(22), location: 1323 }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(24) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(22), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(24), op: Equals, bit_size: U32, lhs: Relative(22), rhs: Relative(1) }, Not { destination: Relative(24), source: Relative(24), bit_size: U1 }, JumpIf { condition: Relative(24), location: 1329 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(3) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(24), source: Direct(32773) }, Mov { destination: Relative(26), source: Direct(32774) }, Store { destination_pointer: Relative(26), source: Relative(28) }, Store { destination_pointer: Relative(5), source: Relative(1) }, Store { destination_pointer: Relative(18), source: Relative(24) }, Load { destination: Relative(3), source_pointer: Relative(24) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(3) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1346 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(24), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(3), location: 1352 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(24), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(3), location: 1358 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(3), source_pointer: Relative(9) }, Load { destination: Relative(18), source_pointer: Relative(3) }, Const { destination: Relative(24), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(26), op: Equals, bit_size: U32, lhs: Relative(24), rhs: Relative(18) }, Not { destination: Relative(26), source: Relative(26), bit_size: U1 }, JumpIf { condition: Relative(26), location: 1366 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(18), op: Add, bit_size: U32, lhs: Relative(18), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(18) }, Mov { destination: Relative(18), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Mov { destination: Relative(26), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(26), source: Relative(3) }, BinaryIntOp { destination: Relative(27), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(17), location: 1417 }, Jump { location: 1377 }, JumpIf { condition: Relative(27), location: 1379 }, Call { location: 2085 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(15) }, JumpIf { condition: Relative(8), location: 1387 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(8), op: Sub, lhs: Relative(5), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(8) }, Load { destination: Relative(3), source_pointer: Relative(5) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(3) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1405 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(3) }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(20) }, Store { destination_pointer: Relative(18), source: Relative(3) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1437 }, JumpIf { condition: Relative(27), location: 1419 }, Call { location: 2085 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(8), op: Equals, lhs: Relative(5), rhs: Relative(13) }, JumpIf { condition: Relative(8), location: 1427 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Mov { destination: Direct(32771), source: Relative(3) }, Call { location: 2088 }, Mov { destination: Relative(5), source: Direct(32772) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(13), source: Relative(19) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(5) }, Jump { location: 1437 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(3), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(3) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1445 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(5), location: 1451 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1457 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(1) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(3), rhs: Relative(11) }, Load { destination: Relative(1), source_pointer: Relative(5) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(1), rhs: Relative(20) }, JumpIf { condition: Relative(3), location: 1465 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 20 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(3), location: 1469 }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1477 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(5) }, Store { destination_pointer: Relative(26), source: Relative(13) }, Jump { location: 1489 }, Load { destination: Relative(1), source_pointer: Relative(18) }, Load { destination: Relative(2), source_pointer: Relative(26) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1497 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(25) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1512 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1518 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1524 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(21) }, Load { destination: Relative(1), source_pointer: Relative(15) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(1), rhs: Relative(25) }, JumpIf { condition: Relative(15), location: 1532 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1538 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(16), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(28) }, Store { destination_pointer: Relative(18), source: Relative(1) }, Store { destination_pointer: Relative(26), source: Relative(16) }, Load { destination: Relative(13), source_pointer: Relative(16) }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(18), op: Equals, bit_size: U32, lhs: Relative(17), rhs: Relative(13) }, Not { destination: Relative(18), source: Relative(18), bit_size: U1 }, JumpIf { condition: Relative(18), location: 1555 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(13) }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(11) }, JumpIf { condition: Relative(13), location: 1561 }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(18) } }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(16), rhs: Relative(10) }, Load { destination: Relative(1), source_pointer: Relative(13) }, BinaryFieldOp { destination: Relative(13), op: Equals, lhs: Relative(1), rhs: Relative(28) }, JumpIf { condition: Relative(13), location: 1567 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Load { destination: Relative(16), source_pointer: Relative(13) }, Const { destination: Relative(18), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(20), op: Equals, bit_size: U32, lhs: Relative(18), rhs: Relative(16) }, Not { destination: Relative(20), source: Relative(20), bit_size: U1 }, JumpIf { condition: Relative(20), location: 1575 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(16), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(16) }, Mov { destination: Relative(16), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Mov { destination: Relative(20), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(20), source: Relative(13) }, BinaryIntOp { destination: Relative(21), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, BinaryIntOp { destination: Relative(22), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Cast { destination: Relative(24), source: Relative(4), bit_size: Field }, Cast { destination: Relative(26), source: Relative(6), bit_size: Field }, Const { destination: Relative(6), bit_size: Field, value: 50 }, JumpIf { condition: Relative(21), location: 1632 }, Jump { location: 1590 }, JumpIf { condition: Relative(22), location: 1592 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Store { destination_pointer: Relative(8), source: Relative(6) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1605 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1620 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(17), source: Direct(32774) }, Store { destination_pointer: Relative(17), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(15) }, Jump { location: 1664 }, JumpIf { condition: Relative(22), location: 1634 }, Call { location: 2085 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(8) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Load { destination: Relative(2), source_pointer: Relative(8) }, BinaryFieldOp { destination: Relative(5), op: Sub, lhs: Relative(2), rhs: Relative(19) }, Mov { destination: Direct(32771), source: Relative(13) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(15) }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1652 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(24) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Jump { location: 1664 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(13), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(13), source: Relative(13), bit_size: U1 }, JumpIf { condition: Relative(13), location: 1672 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(31) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1689 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(11) }, JumpIf { condition: Relative(1), location: 1695 }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(15) } }, JumpIf { condition: Relative(3), location: 1697 }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 1703 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(13) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(8), source: Direct(32774) }, Store { destination_pointer: Relative(8), source: Relative(28) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(5) }, Jump { location: 1715 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1723 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(11), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(25) }, Store { destination_pointer: Relative(16), source: Relative(5) }, Store { destination_pointer: Relative(20), source: Relative(11) }, JumpIf { condition: Relative(3), location: 1754 }, Jump { location: 1736 }, Load { destination: Relative(1), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1742 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Store { destination_pointer: Relative(13), source: Relative(6) }, Store { destination_pointer: Relative(16), source: Relative(1) }, Store { destination_pointer: Relative(20), source: Relative(8) }, Jump { location: 1754 }, Load { destination: Relative(1), source_pointer: Relative(16) }, Load { destination: Relative(2), source_pointer: Relative(20) }, Load { destination: Relative(5), source_pointer: Relative(2) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(5) }, Not { destination: Relative(11), source: Relative(11), bit_size: U1 }, JumpIf { condition: Relative(11), location: 1762 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(5), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 60 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(13), source: Direct(32773) }, Mov { destination: Relative(15), source: Direct(32774) }, Store { destination_pointer: Relative(15), source: Relative(5) }, Store { destination_pointer: Relative(16), source: Relative(11) }, Store { destination_pointer: Relative(20), source: Relative(13) }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1780 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 11 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(1) }, JumpIf { condition: Relative(15), location: 1787 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, BinaryIntOp { destination: Relative(11), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(11), location: 1790 }, Call { location: 2085 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(16) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(4) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(15), op: Equals, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(15), location: 1798 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(11), source_pointer: Relative(13) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1804 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(11), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(11) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(10) }, Load { destination: Relative(11), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(10), op: Equals, lhs: Relative(11), rhs: Relative(31) }, JumpIf { condition: Relative(10), location: 1812 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(10), source_pointer: Relative(13) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1818 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(10) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(10), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(10), rhs: Relative(25) }, JumpIf { condition: Relative(1), location: 1826 }, Const { destination: Relative(16), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(16) } }, Load { destination: Relative(1), source_pointer: Relative(13) }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(10), rhs: Relative(1) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1832 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(13), source: Relative(1) }, Const { destination: Relative(1), bit_size: Integer(U32), value: 12 }, BinaryIntOp { destination: Relative(17), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(16), source_pointer: Relative(17) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(16), rhs: Relative(6) }, JumpIf { condition: Relative(1), location: 1841 }, Const { destination: Relative(17), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(17) } }, Const { destination: Relative(1), bit_size: Integer(U32), value: 13 }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(13), rhs: Relative(1) }, Load { destination: Relative(6), source_pointer: Relative(16) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(6), rhs: Relative(5) }, JumpIf { condition: Relative(1), location: 1848 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Load { destination: Relative(1), source_pointer: Relative(7) }, Load { destination: Relative(5), source_pointer: Relative(9) }, Mov { destination: Relative(6), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Mov { destination: Relative(7), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(7), source: Relative(5) }, JumpIf { condition: Relative(21), location: 1948 }, Jump { location: 1858 }, BinaryIntOp { destination: Relative(2), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, JumpIf { condition: Relative(2), location: 1861 }, Call { location: 2085 }, Mov { destination: Direct(32771), source: Relative(5) }, Call { location: 2088 }, Mov { destination: Relative(2), source: Direct(32772) }, Const { destination: Relative(9), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(9) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Store { destination_pointer: Relative(9), source: Relative(23) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1874 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(26) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1889 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(9), source: Direct(32773) }, Mov { destination: Relative(10), source: Direct(32774) }, Store { destination_pointer: Relative(10), source: Relative(24) }, Load { destination: Relative(4), source_pointer: Relative(9) }, Const { destination: Relative(8), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1904 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U32, lhs: Relative(1), rhs: Relative(12) }, JumpIf { condition: Relative(4), location: 1910 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Load { destination: Relative(1), source_pointer: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(10), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(1) }, Not { destination: Relative(10), source: Relative(10), bit_size: U1 }, JumpIf { condition: Relative(10), location: 1916 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(10), source: Direct(32773) }, Mov { destination: Relative(13), source: Direct(32774) }, Load { destination: Relative(11), source_pointer: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(10) }, Const { destination: Relative(14), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(15), op: Equals, bit_size: U32, lhs: Relative(14), rhs: Relative(13) }, Not { destination: Relative(15), source: Relative(15), bit_size: U1 }, JumpIf { condition: Relative(15), location: 1931 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(10), source: Relative(13) }, Load { destination: Relative(13), source_pointer: Relative(9) }, Const { destination: Relative(15), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(16), op: Equals, bit_size: U32, lhs: Relative(15), rhs: Relative(13) }, Not { destination: Relative(16), source: Relative(16), bit_size: U1 }, JumpIf { condition: Relative(16), location: 1939 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(13), op: Add, bit_size: U32, lhs: Relative(13), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(13) }, BinaryFieldOp { destination: Relative(9), op: Equals, lhs: Relative(11), rhs: Relative(24) }, JumpIf { condition: Relative(9), location: 1945 }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(13) } }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(10) }, Jump { location: 1966 }, Load { destination: Relative(2), source_pointer: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(2) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1954 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(2) }, Store { destination_pointer: Relative(5), source: Relative(2) }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(5) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(24) }, Store { destination_pointer: Relative(6), source: Relative(2) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Jump { location: 1966 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, Load { destination: Relative(4), source_pointer: Relative(2) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(8), op: Equals, bit_size: U32, lhs: Relative(5), rhs: Relative(4) }, Not { destination: Relative(8), source: Relative(8), bit_size: U1 }, JumpIf { condition: Relative(8), location: 1974 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(4) }, BinaryIntOp { destination: Relative(4), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(8), source: Direct(32773) }, Mov { destination: Relative(9), source: Direct(32774) }, Store { destination_pointer: Relative(9), source: Relative(31) }, Store { destination_pointer: Relative(6), source: Relative(4) }, Store { destination_pointer: Relative(7), source: Relative(8) }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 1991 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(12) }, JumpIf { condition: Relative(1), location: 1997 }, Const { destination: Relative(9), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(9) } }, JumpIf { condition: Relative(3), location: 1999 }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(8) }, Const { destination: Relative(2), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U32, lhs: Relative(2), rhs: Relative(1) }, Not { destination: Relative(3), source: Relative(3), bit_size: U1 }, JumpIf { condition: Relative(3), location: 2005 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(8), source: Relative(1) }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(8) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(3), source: Direct(32773) }, Mov { destination: Relative(4), source: Direct(32774) }, Store { destination_pointer: Relative(4), source: Relative(28) }, Store { destination_pointer: Relative(6), source: Relative(1) }, Store { destination_pointer: Relative(7), source: Relative(3) }, Jump { location: 2017 }, Load { destination: Relative(1), source_pointer: Relative(6) }, Load { destination: Relative(2), source_pointer: Relative(7) }, BinaryIntOp { destination: Relative(3), op: Sub, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(2) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(4), source: Direct(32773) }, Mov { destination: Relative(6), source: Direct(32774) }, Load { destination: Relative(5), source_pointer: Relative(6) }, 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: 2032 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(1), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Store { destination_pointer: Relative(4), source: Relative(1) }, BinaryFieldOp { destination: Relative(1), op: Equals, lhs: Relative(5), rhs: Relative(31) }, JumpIf { condition: Relative(1), location: 2038 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, BinaryIntOp { destination: Relative(1), op: Sub, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(4) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2250 }, Mov { destination: Relative(5), source: Direct(32773) }, Mov { destination: Relative(7), source: Direct(32774) }, Load { destination: Relative(6), source_pointer: Relative(7) }, BinaryFieldOp { destination: Relative(3), op: Equals, lhs: Relative(6), rhs: Relative(26) }, JumpIf { condition: Relative(3), location: 2049 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, Return, Load { destination: Relative(10), source_pointer: Relative(7) }, Load { destination: Relative(11), source_pointer: Relative(9) }, Load { destination: Relative(12), source_pointer: Relative(11) }, Const { destination: Relative(13), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(14), op: Equals, bit_size: U32, lhs: Relative(13), rhs: Relative(12) }, Not { destination: Relative(14), source: Relative(14), bit_size: U1 }, JumpIf { condition: Relative(14), location: 2058 }, Call { location: 2082 }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(12), rhs: Direct(2) }, Store { destination_pointer: Relative(11), source: Relative(12) }, Cast { destination: Relative(12), source: Relative(2), bit_size: Field }, BinaryIntOp { destination: Relative(14), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Mov { destination: Direct(32771), source: Relative(11) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 1 }, Call { location: 2114 }, Mov { destination: Relative(15), source: Direct(32773) }, Mov { destination: Relative(16), source: Direct(32774) }, Store { destination_pointer: Relative(16), source: Relative(12) }, Store { destination_pointer: Relative(7), source: Relative(14) }, Store { destination_pointer: Relative(9), source: Relative(15) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(3) }, Mov { destination: Relative(2), source: Relative(10) }, Jump { location: 47 }, 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: 2078 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32773), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32774), op: Equals, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, JumpIf { condition: Direct(32774), location: 2092 }, Jump { location: 2094 }, Mov { destination: Direct(32772), source: Direct(32771) }, Jump { location: 2113 }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32776) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, Const { destination: Direct(32776), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32776) }, Mov { destination: Direct(32772), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32775) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32775) }, Mov { destination: Direct(32778), source: Direct(32771) }, Mov { destination: Direct(32779), source: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: Equals, bit_size: U32, lhs: Direct(32778), rhs: Direct(32777) }, JumpIf { condition: Direct(32780), location: 2111 }, 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: 2104 }, IndirectConst { destination_pointer: Direct(32772), bit_size: Integer(U32), value: 1 }, Jump { location: 2113 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2125 }, Jump { location: 2142 }, JumpIf { condition: Direct(32781), location: 2127 }, Jump { location: 2131 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2141 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2141 }, Jump { location: 2154 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2154 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, JumpIf { condition: Direct(32781), location: 2168 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32776) }, Mov { destination: Direct(32784), source: Direct(32778) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2168 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2161 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32776) }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 5019202896831570965 }, 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: 2177 }, Jump { location: 2179 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 2194 }, 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: 2191 }, 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: 2184 }, 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: 2194 }, Return, Load { destination: Direct(32775), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32779) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32780), op: LessThanEquals, bit_size: U32, lhs: Direct(32779), rhs: Direct(32777) }, BinaryIntOp { destination: Direct(32781), op: Equals, bit_size: U32, lhs: Direct(32775), rhs: Direct(2) }, JumpIf { condition: Direct(32780), location: 2206 }, Jump { location: 2223 }, JumpIf { condition: Direct(32781), location: 2208 }, Jump { location: 2212 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, Jump { location: 2222 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32783) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32782) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32779) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(2) }, Store { destination_pointer: Direct(32782), source: Direct(32777) }, Jump { location: 2222 }, Jump { location: 2235 }, Const { destination: Direct(32783), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32782), op: Mul, bit_size: U32, lhs: Direct(32779), rhs: Direct(32783) }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32782), rhs: Direct(32784) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32779) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32782) }, Jump { location: 2235 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32782), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: LessThan, bit_size: U32, lhs: Direct(32784), rhs: Direct(32778) }, JumpIf { condition: Direct(32782), location: 2248 }, Load { destination: Direct(32785), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32783), source: Direct(32785) }, BinaryIntOp { destination: Direct(32784), op: Sub, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Jump { location: 2241 }, Mov { destination: Direct(32774), source: Direct(32780) }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2259 }, Jump { location: 2263 }, Mov { destination: Direct(32773), source: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2285 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2284 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2277 }, Jump { location: 2285 }, BinaryIntOp { destination: Direct(32774), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32776) }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32778), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, Load { destination: Direct(32776), source_pointer: Direct(32778) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32778), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32779), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32779), location: 2297 }, Jump { location: 2305 }, BinaryIntOp { destination: Direct(32773), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32776), rhs: Direct(32772) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32776) }, Jump { location: 2328 }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32781) }, Mov { destination: Direct(32773), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32780) }, IndirectConst { destination_pointer: Direct(32773), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Store { destination_pointer: Direct(32780), source: Direct(32778) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32773), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32778) }, Mov { destination: Direct(32784), source: Direct(32781) }, Mov { destination: Direct(32785), source: Direct(32780) }, BinaryIntOp { destination: Direct(32786), op: Equals, bit_size: U32, lhs: Direct(32784), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2327 }, Load { destination: Direct(32782), source_pointer: Direct(32784) }, Store { destination_pointer: Direct(32785), source: Direct(32782) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, Jump { location: 2320 }, Jump { location: 2328 }, Return, Load { destination: Direct(32776), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32777), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, Load { destination: Direct(32778), source_pointer: Direct(32780) }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32781), op: LessThanEquals, bit_size: U32, lhs: Direct(32780), rhs: Direct(32778) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, JumpIf { condition: Direct(32781), location: 2340 }, Jump { location: 2357 }, JumpIf { condition: Direct(32782), location: 2342 }, Jump { location: 2346 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, Jump { location: 2356 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32778), rhs: Direct(32784) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32783) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32780) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, Store { destination_pointer: Direct(32783), source: Direct(32778) }, Jump { location: 2356 }, Jump { location: 2369 }, Const { destination: Direct(32784), bit_size: Integer(U32), value: 2 }, BinaryIntOp { destination: Direct(32783), op: Mul, bit_size: U32, lhs: Direct(32780), rhs: Direct(32784) }, Const { destination: Direct(32785), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32785) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32784) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Store { destination_pointer: Direct(32784), source: Direct(32783) }, Jump { location: 2369 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32782) }, BinaryIntOp { destination: Direct(32782), op: Equals, bit_size: U32, lhs: Direct(32771), rhs: Direct(32774) }, JumpIf { condition: Direct(32782), location: 2383 }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32785), source: Direct(32779) }, Mov { destination: Direct(32786), source: Direct(32781) }, BinaryIntOp { destination: Direct(32787), op: Equals, bit_size: U32, lhs: Direct(32785), rhs: Direct(32784) }, JumpIf { condition: Direct(32787), location: 2383 }, Load { destination: Direct(32783), source_pointer: Direct(32785) }, Store { destination_pointer: Direct(32786), source: Direct(32783) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, Jump { location: 2376 }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Sub, bit_size: U32, lhs: Direct(32777), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32786), op: Sub, bit_size: U32, lhs: Direct(32785), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32788), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(32786) }, BinaryIntOp { destination: Direct(32786), op: LessThan, bit_size: U32, lhs: Direct(32788), rhs: Direct(32783) }, JumpIf { condition: Direct(32786), location: 2397 }, Load { destination: Direct(32789), source_pointer: Direct(32788) }, Store { destination_pointer: Direct(32787), source: Direct(32789) }, BinaryIntOp { destination: Direct(32788), op: Sub, bit_size: U32, lhs: Direct(32788), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Sub, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2390 }, Return, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(2) }, Load { destination: Direct(32775), source_pointer: Direct(32775) }, BinaryIntOp { destination: Direct(32776), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32773) }, Load { destination: Direct(32777), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Const { destination: Direct(32780), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32779), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32780) }, JumpIf { condition: Direct(32778), location: 2407 }, Jump { location: 2413 }, Mov { destination: Direct(32774), source: Direct(32771) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, Jump { location: 2435 }, Const { destination: Direct(32782), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(32782) }, Mov { destination: Direct(32774), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(32781) }, IndirectConst { destination_pointer: Direct(32774), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(2) }, Store { destination_pointer: Direct(32781), source: Direct(32776) }, Const { destination: Direct(32781), bit_size: Integer(U32), value: 3 }, BinaryIntOp { destination: Direct(32780), op: Add, bit_size: U32, lhs: Direct(32774), rhs: Direct(32781) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, Mov { destination: Direct(32783), source: Direct(32779) }, Mov { destination: Direct(32784), source: Direct(32780) }, BinaryIntOp { destination: Direct(32785), op: Equals, bit_size: U32, lhs: Direct(32783), rhs: Direct(32782) }, JumpIf { condition: Direct(32785), location: 2434 }, Load { destination: Direct(32781), source_pointer: Direct(32783) }, Store { destination_pointer: Direct(32784), source: Direct(32781) }, BinaryIntOp { destination: Direct(32783), op: Add, bit_size: U32, lhs: Direct(32783), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32784), op: Add, bit_size: U32, lhs: Direct(32784), rhs: Direct(2) }, Jump { location: 2427 }, Jump { location: 2435 }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32779), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32781), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32782), op: Add, bit_size: U32, lhs: Direct(32780), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32775), rhs: Direct(32772) }, BinaryIntOp { destination: Direct(32783), op: Sub, bit_size: U32, lhs: Direct(32783), rhs: Direct(32773) }, BinaryIntOp { destination: Direct(32785), op: Add, bit_size: U32, lhs: Direct(32781), rhs: Direct(32783) }, Mov { destination: Direct(32786), source: Direct(32781) }, Mov { destination: Direct(32787), source: Direct(32782) }, BinaryIntOp { destination: Direct(32788), op: Equals, bit_size: U32, lhs: Direct(32786), rhs: Direct(32785) }, JumpIf { condition: Direct(32788), location: 2450 }, Load { destination: Direct(32784), source_pointer: Direct(32786) }, Store { destination_pointer: Direct(32787), source: Direct(32784) }, BinaryIntOp { destination: Direct(32786), op: Add, bit_size: U32, lhs: Direct(32786), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32787), op: Add, bit_size: U32, lhs: Direct(32787), rhs: Direct(2) }, Jump { location: 2443 }, Return]" ], - "debug_symbols": "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", + "debug_symbols": "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", "file_map": { "50": { "source": "fn main(x: u32) {\n // The parameters to this function must come directly from witness values (inputs to main).\n regression_dynamic_slice_index(x - 1, x - 4);\n}\n\nfn regression_dynamic_slice_index(x: u32, y: u32) {\n let mut slice = &[];\n for i in 0..5 {\n slice = slice.push_back(i as Field);\n }\n assert(slice.len() == 5);\n\n dynamic_slice_index_set_if(slice, x, y);\n dynamic_slice_index_set_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_else(slice, x, y);\n dynamic_slice_index_set_nested_if_else_if(slice, x, y + 1);\n dynamic_slice_index_if(slice, x);\n dynamic_array_index_if([0, 1, 2, 3, 4], x);\n dynamic_slice_index_else(slice, x);\n\n dynamic_slice_merge_if(slice, x);\n dynamic_slice_merge_else(slice, x);\n dynamic_slice_merge_two_ifs(slice, x);\n dynamic_slice_merge_mutate_between_ifs(slice, x, y);\n dynamic_slice_merge_push_then_pop(slice, x, y);\n}\n\nfn dynamic_slice_index_set_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[3] == 2);\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_index_set_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 > 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice[x - 1] = slice[x];\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 0);\n}\n// This tests the case of missing a store instruction in the else branch\n// of merging slices\nfn dynamic_slice_index_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n } else {\n assert(slice[x] == 0);\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_array_index_if(mut array: [Field; 5], x: u32) {\n if x as u32 < 10 {\n assert(array[x] == 4);\n array[x] = array[x] - 2;\n } else {\n assert(array[x] == 0);\n }\n assert(array[4] == 2);\n}\n// This tests the case of missing a store instruction in the then branch\n// of merging slices\nfn dynamic_slice_index_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n }\n assert(slice[4] == 2);\n}\n\nfn dynamic_slice_merge_if(mut slice: [Field], x: u32) {\n if x as u32 < 10 {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n\n slice = slice.push_back(10);\n // Having an array set here checks whether we appropriately\n // handle a slice length that is not yet resolving to a constant\n // during flattening\n slice[x] = 10;\n assert(slice[slice.len() - 1] == 10);\n assert(slice.len() == 6);\n\n slice[x] = 20;\n slice[x] = slice[x] + 10;\n\n slice = slice.push_front(11);\n assert(slice[0] == 11);\n assert(slice.len() == 7);\n assert(slice[5] == 30);\n\n slice = slice.push_front(12);\n assert(slice[0] == 12);\n assert(slice.len() == 8);\n assert(slice[6] == 30);\n\n let (popped_slice, last_elem) = slice.pop_back();\n assert(last_elem == 10);\n assert(popped_slice.len() == 7);\n\n let (first_elem, rest_of_slice) = popped_slice.pop_front();\n assert(first_elem == 12);\n assert(rest_of_slice.len() == 6);\n\n slice = rest_of_slice.insert(x as u32 - 2, 20);\n assert(slice[2] == 20);\n assert(slice[6] == 30);\n assert(slice.len() == 7);\n\n let (removed_slice, removed_elem) = slice.remove(x as u32 - 1);\n // The deconstructed tuple assigns to the slice but is not seen outside of the if statement\n // without a direct assignment\n slice = removed_slice;\n\n assert(removed_elem == 1);\n assert(slice.len() == 6);\n } else {\n assert(slice[x] == 0);\n slice = slice.push_back(20);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 30);\n}\n\nfn dynamic_slice_merge_else(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_else(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 1);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[1] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n if y != 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 5 {\n // We should not hit this case\n assert(slice[x] == 22);\n } else {\n slice[x] = 10;\n slice = slice.push_back(15);\n assert(slice.len() == 6);\n }\n assert(slice[4] == 10);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 10);\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_index_set_nested_if_else_if(mut slice: [Field], x: u32, y: u32) {\n assert(slice[x] == 4);\n assert(slice[y] == 2);\n slice[y] = 0;\n assert(slice[x] == 4);\n assert(slice[2] == 0);\n if x as u32 < 10 {\n slice[x] = slice[x] - 2;\n // TODO: this panics as we have a load for the slice in flattening\n if y == 1 {\n slice[x] = slice[x] + 20;\n } else {\n if x == 4 {\n slice[x] = 5;\n }\n assert(slice[4] == 5);\n }\n } else {\n slice[x] = 0;\n }\n assert(slice[4] == 5);\n}\n\nfn dynamic_slice_merge_two_ifs(mut slice: [Field], x: u32) {\n if x as u32 > 10 {\n assert(slice[x] == 0);\n slice[x] = 2;\n } else {\n assert(slice[x] == 4);\n slice[x] = slice[x] - 2;\n slice = slice.push_back(10);\n }\n\n assert(slice.len() == 6);\n assert(slice[slice.len() - 1] == 10);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n assert(slice.len() == 7);\n assert(slice[slice.len() - 1] == 15);\n\n slice = slice.push_back(20);\n assert(slice.len() == 8);\n assert(slice[slice.len() - 1] == 20);\n}\n\nfn dynamic_slice_merge_mutate_between_ifs(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 50;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n } else {\n slice[x] = slice[x] - 2;\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 8);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n slice = slice.push_back(15);\n\n if x != 20 {\n slice = slice.push_back(50);\n }\n\n slice = slice.push_back(60);\n assert(slice.len() == 11);\n assert(slice[x] == 50);\n assert(slice[slice.len() - 4] == 30);\n assert(slice[slice.len() - 3] == 15);\n assert(slice[slice.len() - 2] == 50);\n assert(slice[slice.len() - 1] == 60);\n}\n\nfn dynamic_slice_merge_push_then_pop(mut slice: [Field], x: u32, y: u32) {\n if x != y {\n slice[x] = 5;\n slice = slice.push_back(y as Field);\n slice = slice.push_back(x as Field);\n assert(slice.len() == 7);\n\n let (popped_slice, elem) = slice.pop_back();\n assert(slice.len() == 7);\n assert(elem == x as Field);\n slice = popped_slice;\n } else {\n slice = slice.push_back(x as Field);\n }\n\n slice = slice.push_back(30);\n assert(slice.len() == 7);\n\n if x == 20 {\n slice = slice.push_back(20);\n }\n\n let (slice, elem) = slice.pop_back();\n assert(elem == 30);\n\n let (_, elem) = slice.pop_back();\n assert(elem == y as Field);\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap index c769628f02b..d063404837e 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_-9223372036854775808.snap @@ -54,9 +54,9 @@ expression: artifact "return value indices : [_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31]", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: [Array([Witness(1), Witness(2), Witness(3), Witness(4), Witness(5), Witness(6), Witness(7), Witness(8), Witness(9), Witness(10), Witness(11), Witness(12), Witness(13), Witness(14), Witness(15), Witness(16), Witness(17), Witness(18), Witness(19), Witness(20), Witness(21), Witness(22), Witness(23), Witness(24), Witness(25), Witness(26), Witness(27), Witness(28), Witness(29), Witness(30), Witness(31)])]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32872 }, 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(32840), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32840) }, Call { location: 19 }, Call { location: 25 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 121 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, 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(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 30 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 31 }, Return, Call { location: 132 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 50 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 44 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(2), source: Direct(32835) }, Jump { location: 55 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 106 }, Jump { location: 58 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(5) }, Not { destination: Relative(4), source: Relative(6), bit_size: U1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(6) }, Not { destination: Relative(5), source: Relative(7), bit_size: U1 }, BinaryIntOp { destination: Relative(6), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 101 }, Jump { location: 79 }, Load { destination: Relative(2), source_pointer: Relative(3) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 86 }, Call { location: 138 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 141 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 99 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Relative(1), source: Relative(2) }, Return, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(2), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Direct(32836) }, JumpIf { condition: Relative(2), location: 106 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(3) } }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(6), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 179 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Store { destination_pointer: Relative(9), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(7) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 55 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 131 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 124 }, 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: 137 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 132 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(4), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(3), source: Relative(4) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(4), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 256 }, Mov { destination: Relative(2), source: Direct(32835) }, Jump { location: 153 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 158 }, Jump { location: 156 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(6), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(8), location: 163 }, Call { location: 201 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 166 }, Call { location: 204 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Cast { destination: Relative(7), source: Relative(8), bit_size: Field }, Load { destination: Relative(8), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(9), op: Mul, lhs: Relative(7), rhs: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(6), rhs: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Mul, lhs: Relative(8), rhs: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(6) }, Jump { location: 153 }, 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: 183 }, Jump { location: 185 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 200 }, 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: 197 }, 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: 190 }, 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: 200 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32872 }, 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(32840), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32840) }, Call { location: 19 }, Call { location: 25 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 122 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32841 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, 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(U1), value: 1 }, Const { destination: Direct(32837), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(32838), bit_size: Integer(U32), value: 30 }, Const { destination: Direct(32839), bit_size: Integer(U32), value: 31 }, Return, Call { location: 133 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 50 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 44 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Mov { destination: Relative(2), source: Direct(32835) }, Jump { location: 55 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(5), location: 107 }, Jump { location: 58 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, Load { destination: Relative(4), source_pointer: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(6), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(5) }, Not { destination: Relative(4), source: Relative(6), bit_size: U1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, Load { destination: Relative(5), source_pointer: Relative(6) }, Const { destination: Relative(6), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(7), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(6) }, Not { destination: Relative(5), source: Relative(7), bit_size: U1 }, BinaryIntOp { destination: Relative(6), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(5) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(5), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(6), rhs: Relative(2) }, JumpIf { condition: Relative(4), location: 79 }, Jump { location: 85 }, Const { destination: Relative(2), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U1, lhs: Relative(2), rhs: Direct(32836) }, JumpIf { condition: Relative(4), location: 84 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Jump { location: 85 }, Load { destination: Relative(2), source_pointer: Relative(3) }, Load { destination: Relative(3), source_pointer: Relative(2) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(5), op: Equals, bit_size: U32, lhs: Relative(4), rhs: Relative(3) }, Not { destination: Relative(5), source: Relative(5), bit_size: U1 }, JumpIf { condition: Relative(5), location: 92 }, Call { location: 139 }, BinaryIntOp { destination: Relative(3), op: Add, bit_size: U32, lhs: Relative(3), rhs: Direct(2) }, Store { destination_pointer: Relative(2), source: Relative(3) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 6 }, Mov { destination: Relative(6), source: Direct(0) }, Mov { destination: Relative(7), source: Relative(2) }, BinaryIntOp { destination: Direct(0), op: Add, bit_size: U32, lhs: Direct(0), rhs: Relative(5) }, Call { location: 142 }, Mov { destination: Direct(0), source: Relative(0) }, Mov { destination: Relative(3), source: Relative(7) }, BinaryFieldOp { destination: Relative(5), op: Equals, lhs: Relative(3), rhs: Relative(1) }, JumpIf { condition: Relative(5), location: 105 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(6) } }, Mov { destination: Relative(1), source: Relative(2) }, Return, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(6), rhs: Relative(2) }, Load { destination: Relative(5), source_pointer: Relative(7) }, Load { destination: Relative(6), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(6) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 180 }, Mov { destination: Relative(7), source: Direct(32773) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(7), rhs: Direct(2) }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(8), rhs: Relative(2) }, Store { destination_pointer: Relative(9), source: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(7) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 55 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 132 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 125 }, 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: 138 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Call { location: 133 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(4), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(3), source: Relative(4) }, Mov { destination: Relative(4), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(5), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(4), source: Relative(5) }, Const { destination: Relative(5), bit_size: Field, value: 256 }, Mov { destination: Relative(2), source: Direct(32835) }, Jump { location: 154 }, BinaryIntOp { destination: Relative(6), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Direct(32839) }, JumpIf { condition: Relative(6), location: 159 }, Jump { location: 157 }, Load { destination: Relative(1), source_pointer: Relative(4) }, Return, Load { destination: Relative(6), source_pointer: Relative(4) }, BinaryIntOp { destination: Relative(7), op: Sub, bit_size: U32, lhs: Direct(32838), rhs: Relative(2) }, BinaryIntOp { destination: Relative(8), op: LessThanEquals, bit_size: U32, lhs: Relative(2), rhs: Direct(32838) }, JumpIf { condition: Relative(8), location: 164 }, Call { location: 202 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(7), rhs: Direct(32839) }, JumpIf { condition: Relative(8), location: 167 }, Call { location: 205 }, BinaryIntOp { destination: Relative(9), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(9), rhs: Relative(7) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Cast { destination: Relative(7), source: Relative(8), bit_size: Field }, Load { destination: Relative(8), source_pointer: Relative(3) }, BinaryFieldOp { destination: Relative(9), op: Mul, lhs: Relative(7), rhs: Relative(8) }, BinaryFieldOp { destination: Relative(7), op: Add, lhs: Relative(6), rhs: Relative(9) }, Store { destination_pointer: Relative(4), source: Relative(7) }, BinaryFieldOp { destination: Relative(6), op: Mul, lhs: Relative(8), rhs: Relative(5) }, Store { destination_pointer: Relative(3), source: Relative(6) }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(2), rhs: Direct(32837) }, Mov { destination: Relative(2), source: Relative(6) }, Jump { location: 154 }, 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: 184 }, Jump { location: 186 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 201 }, 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: 198 }, 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: 191 }, 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: 201 }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return]" ], - "debug_symbols": "pZbNbuowEIXfJWsWHv+NzatUqEppehUpCiiFK11VvPudycyEdkEXZsN3THyOx7EN/ureh7frn9dx/jh9dvuXr+5tGadp/PM6nY79ZTzN9O1X5/jD524fdp1HQRHUFcEJQOAFQRAFqdtHQhagoAjqiugEIPCCIIgCSYmSEiUlSkqUlCQpSVKSpCTyJQL1zATqibsuOwH1LAQvCAIarxKSgMYDR0RlUVIQwK5DSgJPBKVXUhjQ5DEqk5LzqCxkP9VVnBKUXhmUUZmUWYlKrocmVqqwOiUovTIoo5Lz6BXUrERlEYLTgsB5E8FENJFMcEphgSaKiaoC3LoCAKD0yqCMyqTMSlTKCgLvDqgsgoloIpkgr3cs0EQxUVUksntgwZ09i2LfcB9aLOB9IgJMeBPBRDSRTHBgZIEmiglO5jfG+0YEJ/O8eOd4fvO8dURELYw3j4i11Ntt19kpfb0sw8CH9NuxpcN87pdhvnT7+TpNu+5vP13XTp/nfl556Rd6Sq9hmN+JFPgxTgOr2+7udo+twDNdzRDyZk8//fDYn3yx0ZOv9wQoPxL844SM/ErWhIyxPEr4bQ4ZbA7ZP5rDb/6SzF+wxV+L+r3LDX4fNn/E5/wptPjT5s/4nB+bxg+4+WOLH7fxm9bvm78+WX9tqT+AHYAALfWHbfyA7kl/apm/qzZ/33L+StwWgGRt+AUoyWVLSA6bEoLbEgK0JGRnPyMlg2+qIYetBmxLSHhPCM8mlMYa7mtR2tYiPkw4UKs/jsuP6+2Ns5axf5sGbX5c5+O3p5d/Z3ti1+PzcjoO79dl4KT7HZk+XgDrzjt3oGstt+gqAQEOfAfiZvDURG7SP/6Ld0B9w+HGpf0H", + "debug_symbols": "pZZNbuMwDIXv4nUWIvWfqxRB4abuwIDhBG4ywKDI3Yc0SaddpAtlk+8p1nuibMnWV/c+vF3/vI7zx+mz2798dW/LOE3jn9fpdOwv42mmf786xz+Yur3fdZgFRVBXeCcAAQq8IAhitw+EJMiCIqgrghOAAAVeEASSEiQlSEqQlCApUVKipERJieSLBOqZCNQz77rkBNSzEFDgBTReJUQBjQeOmJVFSUEAuy5TEiARlKikMKDJ56CMSs6jsjL7qa7ilKBEpVdGZVJmZVFqTtWcqjlVc6rmVK6DbkCNyqTMyqKsQnDOBCdmFmjCmwgmOKWwKCaqCnAmYH0CAKj0yqCMyqTMyqKsQl4WUFkEE9FEMkFedCyKiaqCF4kIsiOw4M7Iouo/vDzQswATaMKbCCaiiWSCAwOLYqKq4OWCkQWY4GSeF68Y5JvJS0ZE1MJ40YhYS73ddp3t0tfLMgy8Sb9tW9rM534Z5ku3n6/TtOv+9tN17fR57ueVl36hq3QbhvmdSIEf4zSwuu3ubvfYCjzT1Qw+bfb40w+P/RGLjR6x3hOg/EjAxwkp8y1ZE1IO5VHCb3NIYHNI+GgOv/lLNH/JLf5a1I8uNfjRb/6Qn/NH3+KPmz/l5/y5aXyfN39o8edt/Kbn981fn6y/ttTvwTaAh5b6/Ta+z+5Jf2yZv6s2f2zZfyVsD4BkbXgDlOiSJUSXmxK82xI8tCQkZ6+RkgCbakh+qyG3JcR8T/DPJpTGGu7PorQ9i/Aw4UCt/jguP463N85axv5tGrT5cZ2P365e/p3tih2Pz8vpOLxfl4GT7mdk+nkB+qShgwMda7lFnyfweODDEDe9p2bhJn36X9Ah9Q2HG5f2Hw==", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n __assert_max_bit_size(self, BIT_SIZE);\n }\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = __to_le_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = __to_be_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_le_radix(self, radix)\n }\n\n fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_be_radix(self, radix)\n }\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_0.snap index 090dea8685c..230c1c59d0a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_0.snap @@ -54,9 +54,9 @@ expression: artifact "return value indices : [_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31]", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: [Array([Witness(1), Witness(2), Witness(3), Witness(4), Witness(5), Witness(6), Witness(7), Witness(8), Witness(9), Witness(10), Witness(11), Witness(12), Witness(13), Witness(14), Witness(15), Witness(16), Witness(17), Witness(18), Witness(19), Witness(20), Witness(21), Witness(22), Witness(23), Witness(24), Witness(25), Witness(26), Witness(27), Witness(28), Witness(29), Witness(30), Witness(31)])]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32868 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 19 }, Call { location: 20 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 150 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Return, Call { location: 161 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 45 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 39 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 31 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 1 }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 53 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 135 }, Jump { location: 56 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(8) }, Not { destination: Relative(4), source: Relative(9), bit_size: U1 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, Load { destination: Relative(9), source_pointer: Relative(10) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(10) }, Not { destination: Relative(9), source: Relative(11), bit_size: U1 }, BinaryIntOp { destination: Relative(10), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 130 }, Jump { location: 79 }, Load { destination: Relative(9), source_pointer: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 86 }, Call { location: 167 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(12), source: Relative(13) }, Const { destination: Relative(13), bit_size: Field, value: 256 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 99 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 109 }, Jump { location: 102 }, Load { destination: Relative(2), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 107 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Load { destination: Relative(5), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(14), location: 114 }, Call { location: 170 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(14), location: 117 }, Call { location: 173 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Cast { destination: Relative(11), source: Relative(14), bit_size: Field }, Load { destination: Relative(14), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(11), rhs: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(5), rhs: Relative(15) }, Store { destination_pointer: Relative(12), source: Relative(11) }, BinaryFieldOp { destination: Relative(5), op: Mul, lhs: Relative(14), rhs: Relative(13) }, Store { destination_pointer: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 99 }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 135 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, 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(2) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 176 }, Mov { destination: Relative(10), source: Direct(32773) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(3), source: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 53 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 160 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 153 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 166 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 180 }, Jump { location: 182 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 197 }, 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: 194 }, 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: 187 }, 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: 197 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32868 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 19 }, Call { location: 20 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 151 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Return, Call { location: 162 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 45 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 39 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 31 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 1 }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 53 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 136 }, Jump { location: 56 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(8) }, Not { destination: Relative(4), source: Relative(9), bit_size: U1 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, Load { destination: Relative(9), source_pointer: Relative(10) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(10) }, Not { destination: Relative(9), source: Relative(11), bit_size: U1 }, BinaryIntOp { destination: Relative(10), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 79 }, Jump { location: 85 }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 84 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Jump { location: 85 }, Load { destination: Relative(9), source_pointer: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 92 }, Call { location: 168 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(12), source: Relative(13) }, Const { destination: Relative(13), bit_size: Field, value: 256 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 105 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 115 }, Jump { location: 108 }, Load { destination: Relative(2), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 113 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Load { destination: Relative(5), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(14), location: 120 }, Call { location: 171 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(14), location: 123 }, Call { location: 174 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Cast { destination: Relative(11), source: Relative(14), bit_size: Field }, Load { destination: Relative(14), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(11), rhs: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(5), rhs: Relative(15) }, Store { destination_pointer: Relative(12), source: Relative(11) }, BinaryFieldOp { destination: Relative(5), op: Mul, lhs: Relative(14), rhs: Relative(13) }, Store { destination_pointer: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 105 }, 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(2) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 177 }, Mov { destination: Relative(10), source: Direct(32773) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(3), source: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 53 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 161 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 154 }, 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: 167 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 181 }, Jump { location: 183 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 198 }, 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: 195 }, 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: 188 }, 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: 198 }, Return]" ], - "debug_symbols": "pZbNbqswEIXfhTULj//dV6miiqa0QkIkosmVrqK8+51hZkiyILpyNvmOwef4B4b40nz1n+efj2H6Pvw2b++X5nMexnH4+RgP++40HCa8emkM/Vho3lzbWMtwDM8IjMhIjMwoCxyGeAQwLMMxPCMwIiMxMqMs8JziOcVziucUzymeUzyneE4J2CUg8GJE4MWEyAyMzm0TDQMYGF0QjuEZGA0GGYVJiEEASEwC2zbJCEGIYYB7kJzQCykPZ5fIh9PLRghCK3RCLwzCKExCmgeuKBdmMUIQUh4urjihFwYh+XCdYLCjNSSwpwUSXkVQEVUkFWoHHNdaEqDCqnAqvIqgIqqgQEciqygiLCV7EqCCkgMJSo4kvIogq6D3kkUS4WSnwYEKq8Kp8CooJ5GIKpKKrKIsbxbQC7oQhFbohF4YhFGIifF6bRstvI/T3PdUd3eViPV57OZ+OjVv03kc2+ZPN56XTr/Hblp46ma8i0vspy8kBn4PY0/q2t7cZtsKtM+LGZe72sOjH7b9wWYdPdhyS4D8kGC3E2Kit2BJiMnnrYRna4iga4h2aw3P/DmoP6caf8nityZW+K1b/T695g+uxh9Wf0yv+VPV+C6tfl/jT+v4Vc/vzl9enH+pmb8DLQAHNfN36/gumc0ajtsB2a87gLJsleDTiGCiRgST6iKcWSMcVEVEo6WcI9iKb8n9XoaqvQzRratItm4jQrpFuJcjcu0sbk80Vz5R/z8Rz0rLFC0t+/hp32Gr2w/zw9H1Sknz0H2OvTS/z9P+7u7p71Hv6NH3OB/2/dd57inpdv7Fn3dIsYWSdngepVYwLUSzo6MPNfFfB2KkJix98W6yuytN7R8=", + "debug_symbols": "pZbLbqswEIbfhTULj29j91WqqKIprZAQiWhypKMo735mmDFJFkRHzibfb2A+X8CES/PVf55/Pobp+/DbvL1fms95GMfh52M87LvTcJjo6KUx/GOheXNtY63ACbwgCKIABUmQFziSeAIIrMAJvCAIogAFSZAXeLF4sXixeLF4sXixeLF4sQS6JBDoYCTQQSQkAalT20QjAAGpM8EJvIDUYIhRiUoSARDJBLZt0ChBSTKgNUCn9Er20eiQ62h4yShBaZVOGZRRicqkVE9WT1ZPVk9WT+b+aeY5KKMSleyjRchZCMaUACVwaeZA11rDgS62tAgApgQowZbgSijlQF1bywFLSCVkDdaUACXYEljoOPgSQgls9hywBDYHDmym5wD4oZQAOgt+MCW4EtiDHLCEVELWwI8la/i5XGiVTumVQRmVqCRjvF7bpmy7j9Pc97zr7vYh7c5jN/fTqXmbzuPYNn+68bxc9HvspoWnbqazNOp++iKS8HsYe07X9lZttkuBl24ppnmv5eGxHrbrg02l92DzzQDpwWC3DRH5xi6GiD5tGZ7NIUKZQ7Rbc3hWn0KpT1hTn5PWWxMr6q1b6z2+Vh9cTX1Y6yO+Vo9V/Ttc631NPa79V92/u/r84vhzzfgdlA3goGb8bu3fodncw3FbkPy6AhTz1hZ8qggmFkUwWKdwZlU4qFJEU7ZyimAr3iX3axmq1jJEt84Cbd1CBLwp3MuKVDuK2x1NlXfU/4/i2dYyuWwt+/hq31Gr2w/zw4frlU3z0H2OvTa/z9P+7uzp77GcKR++x/mw77/Oc8+m29cv/bwDYksv9x19jXIrQEt/NTv+9OFmtNREbsJyLZ1Ft7vy0P4B", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n __assert_max_bit_size(self, BIT_SIZE);\n }\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = __to_le_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = __to_be_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_le_radix(self, radix)\n }\n\n fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_be_radix(self, radix)\n }\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_9223372036854775807.snap index 090dea8685c..230c1c59d0a 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/to_be_bytes/execute__tests__force_brillig_true_inliner_9223372036854775807.snap @@ -54,9 +54,9 @@ expression: artifact "return value indices : [_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31]", "BRILLIG CALL func 0: inputs: [Single(Expression { mul_terms: [], linear_combinations: [(1, Witness(0))], q_c: 0 })], outputs: [Array([Witness(1), Witness(2), Witness(3), Witness(4), Witness(5), Witness(6), Witness(7), Witness(8), Witness(9), Witness(10), Witness(11), Witness(12), Witness(13), Witness(14), Witness(15), Witness(16), Witness(17), Witness(18), Witness(19), Witness(20), Witness(21), Witness(22), Witness(23), Witness(24), Witness(25), Witness(26), Witness(27), Witness(28), Witness(29), Witness(30), Witness(31)])]", "unconstrained func 0", - "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32868 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 19 }, Call { location: 20 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 150 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Return, Call { location: 161 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 45 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 39 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 31 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 1 }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 53 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 135 }, Jump { location: 56 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(8) }, Not { destination: Relative(4), source: Relative(9), bit_size: U1 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, Load { destination: Relative(9), source_pointer: Relative(10) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(10) }, Not { destination: Relative(9), source: Relative(11), bit_size: U1 }, BinaryIntOp { destination: Relative(10), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 130 }, Jump { location: 79 }, Load { destination: Relative(9), source_pointer: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 86 }, Call { location: 167 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(12), source: Relative(13) }, Const { destination: Relative(13), bit_size: Field, value: 256 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 99 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 109 }, Jump { location: 102 }, Load { destination: Relative(2), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 107 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Load { destination: Relative(5), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(14), location: 114 }, Call { location: 170 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(14), location: 117 }, Call { location: 173 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Cast { destination: Relative(11), source: Relative(14), bit_size: Field }, Load { destination: Relative(14), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(11), rhs: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(5), rhs: Relative(15) }, Store { destination_pointer: Relative(12), source: Relative(11) }, BinaryFieldOp { destination: Relative(5), op: Mul, lhs: Relative(14), rhs: Relative(13) }, Store { destination_pointer: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 99 }, Const { destination: Relative(1), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(3), op: Equals, bit_size: U1, lhs: Relative(1), rhs: Relative(2) }, JumpIf { condition: Relative(3), location: 135 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(4) } }, 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(2) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 176 }, Mov { destination: Relative(10), source: Direct(32773) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(3), source: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 53 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 160 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 153 }, Return, Const { destination: Direct(32772), bit_size: Integer(U32), value: 30720 }, BinaryIntOp { destination: Direct(32771), op: LessThan, bit_size: U32, lhs: Direct(0), rhs: Direct(32772) }, JumpIf { condition: Direct(32771), location: 166 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 180 }, Jump { location: 182 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 197 }, 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: 194 }, 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: 187 }, 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: 197 }, Return]" + "[Const { destination: Direct(2), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(1), bit_size: Integer(U32), value: 32868 }, Const { destination: Direct(0), bit_size: Integer(U32), value: 3 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 1 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(32836), size_address: Relative(2), offset_address: Relative(3) }, Mov { destination: Relative(1), source: Direct(32836) }, Call { location: 19 }, Call { location: 20 }, BinaryIntOp { destination: Relative(2), op: Add, bit_size: U32, lhs: Relative(1), rhs: Direct(2) }, Const { destination: Relative(3), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(4), bit_size: Integer(U32), value: 31 }, Mov { destination: Direct(32771), source: Relative(2) }, Mov { destination: Direct(32772), source: Relative(3) }, Mov { destination: Direct(32773), source: Relative(4) }, Call { location: 151 }, Const { destination: Relative(2), bit_size: Integer(U32), value: 32837 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 31 }, Stop { return_data: HeapVector { pointer: Relative(2), size: Relative(3) } }, Return, Call { location: 162 }, Const { destination: Relative(3), bit_size: Integer(U32), value: 256 }, Const { destination: Relative(5), bit_size: Integer(U1), value: 0 }, Mov { destination: Relative(4), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Relative(6) }, IndirectConst { destination_pointer: Relative(4), bit_size: Integer(U32), value: 1 }, BinaryIntOp { destination: Relative(6), op: Add, bit_size: U32, lhs: Relative(4), rhs: Direct(2) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BlackBox(ToRadix { input: Relative(1), radix: Relative(3), output_pointer: Relative(6), num_limbs: Relative(7), output_bits: Relative(5) }), Const { destination: Relative(3), bit_size: Integer(U8), value: 0 }, Mov { destination: Relative(5), source: Direct(1) }, Const { destination: Relative(6), bit_size: Integer(U32), value: 32 }, 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) }, Const { destination: Relative(7), bit_size: Integer(U32), value: 31 }, BinaryIntOp { destination: Relative(7), op: Add, bit_size: U32, lhs: Relative(7), rhs: Relative(6) }, Mov { destination: Relative(8), source: Relative(6) }, BinaryIntOp { destination: Relative(9), op: LessThan, bit_size: U32, lhs: Relative(8), rhs: Relative(7) }, Not { destination: Relative(9), source: Relative(9), bit_size: U1 }, JumpIf { condition: Relative(9), location: 45 }, Store { destination_pointer: Relative(8), source: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(8), rhs: Direct(2) }, Jump { location: 39 }, Mov { destination: Relative(3), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Store { destination_pointer: Relative(3), source: Relative(5) }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Const { destination: Relative(6), bit_size: Integer(U32), value: 31 }, Const { destination: Relative(7), bit_size: Integer(U32), value: 1 }, Mov { destination: Relative(2), source: Relative(5) }, Jump { location: 53 }, BinaryIntOp { destination: Relative(8), op: LessThan, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, JumpIf { condition: Relative(8), location: 136 }, Jump { location: 56 }, Load { destination: Relative(2), source_pointer: Relative(3) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(6) }, Load { destination: Relative(4), source_pointer: Relative(8) }, Const { destination: Relative(8), bit_size: Integer(U8), value: 60 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U8, lhs: Relative(4), rhs: Relative(8) }, Not { destination: Relative(4), source: Relative(9), bit_size: U1 }, Const { destination: Relative(8), bit_size: Integer(U32), value: 30 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(8) }, Load { destination: Relative(9), source_pointer: Relative(10) }, Const { destination: Relative(10), bit_size: Integer(U8), value: 33 }, BinaryIntOp { destination: Relative(11), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(10) }, Not { destination: Relative(9), source: Relative(11), bit_size: U1 }, BinaryIntOp { destination: Relative(10), op: Or, bit_size: U1, lhs: Relative(4), rhs: Relative(9) }, Const { destination: Relative(4), bit_size: Integer(U32), value: 29 }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(4) }, Load { destination: Relative(9), source_pointer: Relative(11) }, Const { destination: Relative(2), bit_size: Integer(U8), value: 31 }, BinaryIntOp { destination: Relative(4), op: Equals, bit_size: U8, lhs: Relative(9), rhs: Relative(2) }, Not { destination: Relative(2), source: Relative(4), bit_size: U1 }, BinaryIntOp { destination: Relative(4), op: Or, bit_size: U1, lhs: Relative(10), rhs: Relative(2) }, Const { destination: Relative(2), bit_size: Integer(U1), value: 1 }, JumpIf { condition: Relative(4), location: 79 }, Jump { location: 85 }, Const { destination: Relative(4), bit_size: Integer(U1), value: 0 }, BinaryIntOp { destination: Relative(9), op: Equals, bit_size: U1, lhs: Relative(4), rhs: Relative(2) }, JumpIf { condition: Relative(9), location: 84 }, Const { destination: Relative(10), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(10) } }, Jump { location: 85 }, Load { destination: Relative(9), source_pointer: Relative(3) }, Load { destination: Relative(10), source_pointer: Relative(9) }, Const { destination: Relative(11), bit_size: Integer(U32), value: 0 }, BinaryIntOp { destination: Relative(12), op: Equals, bit_size: U32, lhs: Relative(11), rhs: Relative(10) }, Not { destination: Relative(12), source: Relative(12), bit_size: U1 }, JumpIf { condition: Relative(12), location: 92 }, Call { location: 168 }, BinaryIntOp { destination: Relative(10), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, Store { destination_pointer: Relative(9), source: Relative(10) }, Mov { destination: Relative(10), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(12), bit_size: Field, value: 1 }, Store { destination_pointer: Relative(10), source: Relative(12) }, Mov { destination: Relative(12), source: Direct(1) }, BinaryIntOp { destination: Direct(1), op: Add, bit_size: U32, lhs: Direct(1), rhs: Direct(2) }, Const { destination: Relative(13), bit_size: Field, value: 0 }, Store { destination_pointer: Relative(12), source: Relative(13) }, Const { destination: Relative(13), bit_size: Field, value: 256 }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 105 }, BinaryIntOp { destination: Relative(5), op: LessThan, bit_size: U32, lhs: Relative(4), rhs: Relative(6) }, JumpIf { condition: Relative(5), location: 115 }, Jump { location: 108 }, Load { destination: Relative(2), source_pointer: Relative(12) }, BinaryFieldOp { destination: Relative(4), op: Equals, lhs: Relative(2), rhs: Relative(1) }, JumpIf { condition: Relative(4), location: 113 }, Const { destination: Relative(5), bit_size: Integer(U32), value: 0 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Relative(5) } }, Load { destination: Relative(1), source_pointer: Relative(3) }, Return, Load { destination: Relative(5), source_pointer: Relative(12) }, BinaryIntOp { destination: Relative(11), op: Sub, bit_size: U32, lhs: Relative(8), rhs: Relative(4) }, BinaryIntOp { destination: Relative(14), op: LessThanEquals, bit_size: U32, lhs: Relative(4), rhs: Relative(8) }, JumpIf { condition: Relative(14), location: 120 }, Call { location: 171 }, BinaryIntOp { destination: Relative(14), op: LessThan, bit_size: U32, lhs: Relative(11), rhs: Relative(6) }, JumpIf { condition: Relative(14), location: 123 }, Call { location: 174 }, BinaryIntOp { destination: Relative(15), op: Add, bit_size: U32, lhs: Relative(9), rhs: Direct(2) }, BinaryIntOp { destination: Relative(16), op: Add, bit_size: U32, lhs: Relative(15), rhs: Relative(11) }, Load { destination: Relative(14), source_pointer: Relative(16) }, Cast { destination: Relative(11), source: Relative(14), bit_size: Field }, Load { destination: Relative(14), source_pointer: Relative(10) }, BinaryFieldOp { destination: Relative(15), op: Mul, lhs: Relative(11), rhs: Relative(14) }, BinaryFieldOp { destination: Relative(11), op: Add, lhs: Relative(5), rhs: Relative(15) }, Store { destination_pointer: Relative(12), source: Relative(11) }, BinaryFieldOp { destination: Relative(5), op: Mul, lhs: Relative(14), rhs: Relative(13) }, Store { destination_pointer: Relative(10), source: Relative(5) }, BinaryIntOp { destination: Relative(5), op: Add, bit_size: U32, lhs: Relative(4), rhs: Relative(7) }, Mov { destination: Relative(4), source: Relative(5) }, Jump { location: 105 }, 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(2) }, Load { destination: Relative(8), source_pointer: Relative(10) }, Load { destination: Relative(9), source_pointer: Relative(3) }, Mov { destination: Direct(32771), source: Relative(9) }, Const { destination: Direct(32772), bit_size: Integer(U32), value: 32 }, Call { location: 177 }, Mov { destination: Relative(10), source: Direct(32773) }, BinaryIntOp { destination: Relative(11), op: Add, bit_size: U32, lhs: Relative(10), rhs: Direct(2) }, BinaryIntOp { destination: Relative(12), op: Add, bit_size: U32, lhs: Relative(11), rhs: Relative(2) }, Store { destination_pointer: Relative(12), source: Relative(8) }, Store { destination_pointer: Relative(3), source: Relative(10) }, BinaryIntOp { destination: Relative(8), op: Add, bit_size: U32, lhs: Relative(2), rhs: Relative(7) }, Mov { destination: Relative(2), source: Relative(8) }, Jump { location: 53 }, BinaryIntOp { destination: Direct(32775), op: Add, bit_size: U32, lhs: Direct(32771), rhs: Direct(32773) }, Mov { destination: Direct(32776), source: Direct(32771) }, Mov { destination: Direct(32777), source: Direct(32772) }, BinaryIntOp { destination: Direct(32778), op: Equals, bit_size: U32, lhs: Direct(32776), rhs: Direct(32775) }, JumpIf { condition: Direct(32778), location: 161 }, Load { destination: Direct(32774), source_pointer: Direct(32776) }, Store { destination_pointer: Direct(32777), source: Direct(32774) }, BinaryIntOp { destination: Direct(32776), op: Add, bit_size: U32, lhs: Direct(32776), rhs: Direct(2) }, BinaryIntOp { destination: Direct(32777), op: Add, bit_size: U32, lhs: Direct(32777), rhs: Direct(2) }, Jump { location: 154 }, 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: 167 }, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 17843811134343075018 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 12049594436772143978 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 2920182694213909827 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, IndirectConst { destination_pointer: Direct(1), bit_size: Integer(U64), value: 14225679739041873922 }, Trap { revert_data: HeapVector { pointer: Direct(1), size: Direct(2) } }, Return, Load { destination: Direct(32774), source_pointer: Direct(32771) }, BinaryIntOp { destination: Direct(32775), op: Equals, bit_size: U32, lhs: Direct(32774), rhs: Direct(2) }, JumpIf { condition: Direct(32775), location: 181 }, Jump { location: 183 }, Mov { destination: Direct(32773), source: Direct(32771) }, Jump { location: 198 }, 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: 195 }, 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: 188 }, 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: 198 }, Return]" ], - "debug_symbols": "pZbNbqswEIXfhTULj//dV6miiqa0QkIkosmVrqK8+51hZkiyILpyNvmOwef4B4b40nz1n+efj2H6Pvw2b++X5nMexnH4+RgP++40HCa8emkM/Vho3lzbWMtwDM8IjMhIjMwoCxyGeAQwLMMxPCMwIiMxMqMs8JziOcVziucUzymeUzyneE4J2CUg8GJE4MWEyAyMzm0TDQMYGF0QjuEZGA0GGYVJiEEASEwC2zbJCEGIYYB7kJzQCykPZ5fIh9PLRghCK3RCLwzCKExCmgeuKBdmMUIQUh4urjihFwYh+XCdYLCjNSSwpwUSXkVQEVUkFWoHHNdaEqDCqnAqvIqgIqqgQEciqygiLCV7EqCCkgMJSo4kvIogq6D3kkUS4WSnwYEKq8Kp8CooJ5GIKpKKrKIsbxbQC7oQhFbohF4YhFGIifF6bRstvI/T3PdUd3eViPV57OZ+OjVv03kc2+ZPN56XTr/Hblp46ma8i0vspy8kBn4PY0/q2t7cZtsKtM+LGZe72sOjH7b9wWYdPdhyS4D8kGC3E2Kit2BJiMnnrYRna4iga4h2aw3P/DmoP6caf8nityZW+K1b/T695g+uxh9Wf0yv+VPV+C6tfl/jT+v4Vc/vzl9enH+pmb8DLQAHNfN36/gumc0ajtsB2a87gLJsleDTiGCiRgST6iKcWSMcVEVEo6WcI9iKb8n9XoaqvQzRratItm4jQrpFuJcjcu0sbk80Vz5R/z8Rz0rLFC0t+/hp32Gr2w/zw9H1Sknz0H2OvTS/z9P+7u7p71Hv6NH3OB/2/dd57inpdv7Fn3dIsYWSdngepVYwLUSzo6MPNfFfB2KkJix98W6yuytN7R8=", + "debug_symbols": "pZbLbqswEIbfhTULj29j91WqqKIprZAQiWhypKMo735mmDFJFkRHzibfb2A+X8CES/PVf55/Pobp+/DbvL1fms95GMfh52M87LvTcJjo6KUx/GOheXNtY63ACbwgCKIABUmQFziSeAIIrMAJvCAIogAFSZAXeLF4sXixeLF4sXixeLF4sQS6JBDoYCTQQSQkAalT20QjAAGpM8EJvIDUYIhRiUoSARDJBLZt0ChBSTKgNUCn9Er20eiQ62h4yShBaZVOGZRRicqkVE9WT1ZPVk9WT+b+aeY5KKMSleyjRchZCMaUACVwaeZA11rDgS62tAgApgQowZbgSijlQF1bywFLSCVkDdaUACXYEljoOPgSQgls9hywBDYHDmym5wD4oZQAOgt+MCW4EtiDHLCEVELWwI8la/i5XGiVTumVQRmVqCRjvF7bpmy7j9Pc97zr7vYh7c5jN/fTqXmbzuPYNn+68bxc9HvspoWnbqazNOp++iKS8HsYe07X9lZttkuBl24ppnmv5eGxHrbrg02l92DzzQDpwWC3DRH5xi6GiD5tGZ7NIUKZQ7Rbc3hWn0KpT1hTn5PWWxMr6q1b6z2+Vh9cTX1Y6yO+Vo9V/Ttc631NPa79V92/u/r84vhzzfgdlA3goGb8bu3fodncw3FbkPy6AhTz1hZ8qggmFkUwWKdwZlU4qFJEU7ZyimAr3iX3axmq1jJEt84Cbd1CBLwp3MuKVDuK2x1NlXfU/4/i2dYyuWwt+/hq31Gr2w/zw4frlU3z0H2OvTa/z9P+7uzp77GcKR++x/mw77/Oc8+m29cv/bwDYksv9x19jXIrQEt/NTv+9OFmtNREbsJyLZ1Ft7vy0P4B", "file_map": { "18": { "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n /// Asserts that `self` can be represented in `bit_size` bits.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n // docs:start:assert_max_bit_size\n pub fn assert_max_bit_size(self) {\n // docs:end:assert_max_bit_size\n static_assert(\n BIT_SIZE < modulus_num_bits() as u32,\n \"BIT_SIZE must be less than modulus_num_bits\",\n );\n __assert_max_bit_size(self, BIT_SIZE);\n }\n\n /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n /// This slice will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_le_bits\n pub fn to_le_bits(self: Self) -> [u1; N] {\n // docs:end:to_le_bits\n let bits = __to_le_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[N - 1 - i] != p[N - 1 - i]) {\n assert(p[N - 1 - i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n /// This array will be zero padded should not all bits be necessary to represent `self`.\n ///\n /// # Failures\n /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n /// be able to represent the original `Field`.\n ///\n /// # Safety\n /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n // docs:start:to_be_bits\n pub fn to_be_bits(self: Self) -> [u1; N] {\n // docs:end:to_be_bits\n let bits = __to_be_bits(self);\n\n if !is_unconstrained() {\n // Ensure that the decomposition does not overflow the modulus\n let p = modulus_be_bits();\n assert(bits.len() <= p.len());\n let mut ok = bits.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bits[i] != p[i]) {\n assert(p[i] == 1);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bits\n }\n\n /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_le_bytes\n pub fn to_le_bytes(self: Self) -> [u8; N] {\n // docs:end:to_le_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_le_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_le_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[N - 1 - i] != p[N - 1 - i]) {\n assert(bytes[N - 1 - i] < p[N - 1 - i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n /// This array will be zero padded should not all bytes be necessary to represent `self`.\n ///\n /// # Failures\n /// The length N of the array must be big enough to contain all the bytes of the 'self',\n /// and no more than the number of bytes required to represent the field modulus\n ///\n /// # Safety\n /// The result is ensured to be the canonical decomposition of the field element\n // docs:start:to_be_bytes\n pub fn to_be_bytes(self: Self) -> [u8; N] {\n // docs:end:to_be_bytes\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n // Compute the byte decomposition\n let bytes = self.to_be_radix(256);\n\n if !is_unconstrained() {\n // Ensure that the byte decomposition does not overflow the modulus\n let p = modulus_be_bytes();\n assert(bytes.len() <= p.len());\n let mut ok = bytes.len() != p.len();\n for i in 0..N {\n if !ok {\n if (bytes[i] != p[i]) {\n assert(bytes[i] < p[i]);\n ok = true;\n }\n }\n }\n assert(ok);\n }\n bytes\n }\n\n fn to_le_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_le_radix(self, radix)\n }\n\n fn to_be_radix(self: Self, radix: u32) -> [u8; N] {\n // Brillig does not need an immediate radix\n if !crate::runtime::is_unconstrained() {\n static_assert(1 < radix, \"radix must be greater than 1\");\n static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n }\n __to_be_radix(self, radix)\n }\n\n // Returns self to the power of the given exponent value.\n // Caution: we assume the exponent fits into 32 bits\n // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n pub fn pow_32(self, exponent: Field) -> Field {\n let mut r: Field = 1;\n let b: [u1; 32] = exponent.to_le_bits();\n\n for i in 1..33 {\n r *= r;\n r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n }\n r\n }\n\n // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits(value: Field) -> [u1; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n }\n // docs:end:to_be_bits_example\n\n #[test]\n // docs:start:to_le_bits_example\n fn test_to_le_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n }\n // docs:end:to_le_bits_example\n\n #[test]\n // docs:start:to_be_bytes_example\n fn test_to_be_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_be_bytes();\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_bytes_example\n\n #[test]\n // docs:start:to_le_bytes_example\n fn test_to_le_bytes() {\n let field = 2;\n let bytes: [u8; 8] = field.to_le_bytes();\n assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_bytes_example\n\n #[test]\n // docs:start:to_be_radix_example\n fn test_to_be_radix() {\n // 259, in base 256, big endian, is [1, 3].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_be_radix(256);\n assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n assert_eq(Field::from_be_bytes::<8>(bytes), field);\n }\n // docs:end:to_be_radix_example\n\n #[test]\n // docs:start:to_le_radix_example\n fn test_to_le_radix() {\n // 259, in base 256, little endian, is [3, 1].\n // i.e. 3 * 256^0 + 1 * 256^1\n let field = 259;\n\n // The radix (in this example, 256) must be a power of 2.\n // The length of the returned byte array can be specified to be\n // >= the amount of space needed.\n let bytes: [u8; 8] = field.to_le_radix(256);\n assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n assert_eq(Field::from_le_bytes::<8>(bytes), field);\n }\n // docs:end:to_le_radix_example\n\n #[test(should_fail_with = \"radix must be greater than 1\")]\n fn test_to_le_radix_1() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(1);\n } else {\n panic(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\n //fn test_to_le_radix_brillig_1() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test(should_fail_with = \"radix must be a power of 2\")]\n fn test_to_le_radix_3() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(3);\n } else {\n panic(f\"radix must be a power of 2\");\n }\n }\n\n #[test]\n fn test_to_le_radix_brillig_3() {\n // this test should only fail in constrained mode\n if runtime::is_unconstrained() {\n let field = 1;\n let out: [u8; 8] = field.to_le_radix(3);\n let mut expected = [0; 8];\n expected[0] = 1;\n assert(out == expected, \"unexpected result\");\n }\n }\n\n #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n fn test_to_le_radix_512() {\n // this test should only fail in constrained mode\n if !runtime::is_unconstrained() {\n let field = 2;\n let _: [u8; 8] = field.to_le_radix(512);\n } else {\n panic(f\"radix must be less than or equal to 256\")\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\n // // this test should only fail in constrained mode\n // if runtime::is_unconstrained() {\n // let field = 1;\n // let out: [u8; 8] = field.to_le_radix(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\n //}\n\n #[test]\n unconstrained fn test_field_less_than() {\n assert(field_less_than(0, 1));\n assert(field_less_than(0, 0x100));\n assert(field_less_than(0x100, 0 - 1));\n assert(!field_less_than(0 - 1, 0));\n }\n}\n", From 8abe8f8b315f702548ab0b377d61b383090b334f Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 24 Jun 2025 11:37:53 +0100 Subject: [PATCH 36/41] Try with dummy ref --- .../opt/remove_unreachable_instructions.rs | 71 ++++++++----------- 1 file changed, 29 insertions(+), 42 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index cd2096f3c0d..1168bd72c8f 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -7,7 +7,6 @@ //! by that block. use std::sync::Arc; -use acvm::{AcirField, FieldElement}; use fxhash::FxHashSet as HashSet; use noirc_errors::call_stack::CallStackId; @@ -90,7 +89,7 @@ impl Function { let mut terminator = self.dfg[block_id].take_terminator(); terminator.map_values_mut(|value_id| { let typ = self.dfg.type_of_value(value_id); - zeroed_value(self, block_id, &typ) + dummy_ref(self, block_id, typ) }); self.dfg[block_id].set_terminator(terminator); } @@ -124,46 +123,34 @@ fn add_dominated_blocks( } } -fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> ValueId { - match typ { - Type::Numeric(numeric_type) => { - function.dfg.make_constant(FieldElement::zero(), *numeric_type) - } - Type::Array(element_types, len) => { - let mut array = im::Vector::new(); - for _ in 0..*len { - for typ in element_types.iter() { - array.push_back(zeroed_value(function, block_id, typ)); - } - } - let instruction = Instruction::MakeArray { elements: array, typ: typ.clone() }; - let stack = CallStackId::root(); - function.dfg.insert_instruction_and_results(instruction, block_id, None, stack).first() - } - Type::Slice(_) => { - let array = im::Vector::new(); - let instruction = Instruction::MakeArray { elements: array, typ: typ.clone() }; - let stack = CallStackId::root(); - function.dfg.insert_instruction_and_results(instruction, block_id, None, stack).first() - } - Type::Reference(element_type) => { - let instruction = Instruction::Allocate; - let reference_type = Type::Reference(Arc::new((**element_type).clone())); - function - .dfg - .insert_instruction_and_results( - instruction, - block_id, - Some(vec![reference_type]), - CallStackId::root(), - ) - .first() - } - Type::Function => { - // We can have the function return itself. It's fine because the terminator is unreachable anyway. - function.dfg.import_function(function.id()) - } - } +/// Pretend that we have a value for the terminator by allocating a reference and loading it. +/// +/// We will never store to this reference, so it would be an error to actually execute the instruction, +/// but it should prevent the SSA optimizations from simplifying `JmpIf` instructions into `Jmp` if we +/// use some kind of constant value instead, which would alter the CFG and cause other issues, +/// such as infinite loops, that other passes would have difficulty dealing with. +/// +/// The alternative to this is to have a new kind of _unreachable_ terminator instruction. +fn dummy_ref(function: &mut Function, block_id: BasicBlockId, typ: Type) -> ValueId { + // Pretend that we have a reference for the appropriate type. + let instruction = Instruction::Allocate; + let reference_type = Type::Reference(Arc::new(typ.clone())); + let reference_id = function + .dfg + .insert_instruction_and_results( + instruction, + block_id, + Some(vec![reference_type]), + CallStackId::root(), + ) + .first(); + + // Load the reference. We should never execute this instruction, because the code is unreachable. + let instruction = Instruction::Load { address: reference_id }; + function + .dfg + .insert_instruction_and_results(instruction, block_id, Some(vec![typ]), CallStackId::root()) + .first() } #[cfg(test)] From 2e13bd68f2c5755097f1d58d80b58c49c9949ea1 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 24 Jun 2025 11:59:05 +0100 Subject: [PATCH 37/41] Use reverse post order --- .../opt/remove_unreachable_instructions.rs | 49 +++++------------ .../src/ssa/opt/simple_optimization.rs | 55 +++++++++++++++++-- 2 files changed, 65 insertions(+), 39 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 1168bd72c8f..c5f8d180d86 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -12,8 +12,8 @@ use noirc_errors::call_stack::CallStackId; use crate::ssa::{ ir::{ - basic_block::BasicBlockId, dfg::DataFlowGraph, dom::DominatorTree, function::Function, - instruction::Instruction, types::Type, value::ValueId, + basic_block::BasicBlockId, cfg::ControlFlowGraph, function::Function, + instruction::Instruction, post_order::PostOrder, types::Type, value::ValueId, }, ssa_gen::Ssa, }; @@ -29,7 +29,11 @@ impl Ssa { impl Function { fn remove_unreachable_instructions(&mut self) { - let mut dom = DominatorTree::with_function(self); + // Iterate each block in reverse post order = forward order + let cfg = ControlFlowGraph::with_function(self); + let mut block_order = PostOrder::with_cfg(&cfg).into_vec(); + // Start with the entry, process all blocks before their successors. + block_order.reverse(); // The current block we are currently processing let mut current_block_id = None; @@ -41,12 +45,18 @@ impl Function { // At the end we'll zero out their terminators. let mut unreachable_blocks = HashSet::default(); - self.simple_reachable_blocks_optimization(|context| { + self.blocks_optimization(block_order, |context| { let block_id = context.block_id; if current_block_id != Some(block_id) { current_block_id = Some(block_id); - current_block_instructions_are_unreachable = unreachable_blocks.contains(&block_id); + current_block_instructions_are_unreachable = cfg + .predecessors(block_id) + .all(|block_id| unreachable_blocks.contains(&block_id)); + + if current_block_instructions_are_unreachable { + unreachable_blocks.insert(block_id); + } } if current_block_instructions_are_unreachable { @@ -80,8 +90,6 @@ impl Function { if is_unreachable { unreachable_blocks.insert(block_id); current_block_instructions_are_unreachable = true; - - add_dominated_blocks(block_id, context.dfg, &mut dom, &mut unreachable_blocks); } }); @@ -96,33 +104,6 @@ impl Function { } } -/// Adds all of a block's dominated blocks to the `unreachable_blocks` set if they are dominated by that block. -fn add_dominated_blocks( - block_id: BasicBlockId, - dfg: &DataFlowGraph, - dom: &mut DominatorTree, - unreachable_blocks: &mut HashSet, -) { - // First compute the set of all blocks that are reachable from the starting block - let mut reachable_blocks = HashSet::default(); - - let mut blocks_to_process = vec![block_id]; - while let Some(block_id) = blocks_to_process.pop() { - for successor in dfg[block_id].successors() { - if reachable_blocks.insert(successor) { - blocks_to_process.push(successor); - } - } - } - - // Now add them to `unreachable_blocks` if they are dominated by the block - for reachable_block in reachable_blocks { - if dom.dominates(block_id, reachable_block) { - unreachable_blocks.insert(reachable_block); - } - } -} - /// Pretend that we have a value for the terminator by allocating a reference and loading it. /// /// We will never store to this reference, so it would be an error to actually execute the instruction, diff --git a/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs b/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs index 63a9e43099b..55151ed70fe 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/simple_optimization.rs @@ -48,16 +48,61 @@ impl Function { /// /// `replace_value` can be used to replace a value with another one. This substitution will be /// performed in all subsequent instructions. - pub(crate) fn simple_reachable_blocks_optimization_result( - &mut self, - mut f: F, - ) -> RtResult<()> + pub(crate) fn simple_reachable_blocks_optimization_result(&mut self, f: F) -> RtResult<()> where F: FnMut(&mut SimpleOptimizationContext<'_, '_>) -> RtResult<()>, + { + self.blocks_optimization_result(self.reachable_blocks(), f) + } + + /// Performs a simple optimization according to the given callback, returning early if + /// an error occurred. + /// + /// The blocks are traversed in the order in the `blocks` iterator, and instructions in those blocks + /// are then traversed in turn. For each one, `f` will be called with a context. + /// + /// The current instruction will be inserted at the end of the callback given to `mutate` unless + /// `remove_current_instruction` or `insert_current_instruction` are called. + /// + /// `insert_current_instruction` is useful if you need to insert new instructions after the current + /// one, so this can be done before the callback ends. + /// + /// `replace_value` can be used to replace a value with another one. This substitution will be + /// performed in all subsequent instructions. + pub(crate) fn blocks_optimization(&mut self, blocks: I, mut f: F) + where + I: IntoIterator, + F: FnMut(&mut SimpleOptimizationContext<'_, '_>), + { + self.blocks_optimization_result(blocks, move |context| { + f(context); + Ok(()) + }) + .expect("`f` cannot error internally so this should be unreachable"); + } + + /// Performs a simple optimization according to the given callback, returning early if + /// an error occurred. + /// + /// The blocks are traversed in the order in the `blocks` iterator, and instructions in those blocks + /// are then traversed in turn. For each one, `f` will be called with a context. + /// + /// The current instruction will be inserted at the end of the callback given to `mutate` unless + /// `remove_current_instruction` or `insert_current_instruction` are called. + /// + /// `insert_current_instruction` is useful if you need to insert new instructions after the current + /// one, so this can be done before the callback ends. + /// + /// `replace_value` can be used to replace a value with another one. This substitution will be + /// performed in all subsequent instructions. + pub(crate) fn blocks_optimization_result(&mut self, blocks: I, mut f: F) -> RtResult<()> + where + I: IntoIterator, + F: FnMut(&mut SimpleOptimizationContext<'_, '_>) -> RtResult<()>, { let mut values_to_replace = ValueMapping::default(); - for block_id in self.reachable_blocks() { + for block_id in blocks { let instruction_ids = self.dfg[block_id].take_instructions(); self.dfg[block_id].instructions_mut().reserve(instruction_ids.len()); for instruction_id in &instruction_ids { From 0f59793427eae175bd5955dc3c711ad60651ce40 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 24 Jun 2025 12:17:08 +0100 Subject: [PATCH 38/41] Fix: if no predecessors then reachable --- .../opt/remove_unreachable_instructions.rs | 44 ++++++++++++++----- 1 file changed, 32 insertions(+), 12 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index c5f8d180d86..acbd31d6053 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -29,6 +29,7 @@ impl Ssa { impl Function { fn remove_unreachable_instructions(&mut self) { + println!("remove_unreachable_instructions from {}", self.id()); // Iterate each block in reverse post order = forward order let cfg = ControlFlowGraph::with_function(self); let mut block_order = PostOrder::with_cfg(&cfg).into_vec(); @@ -50,9 +51,11 @@ impl Function { if current_block_id != Some(block_id) { current_block_id = Some(block_id); - current_block_instructions_are_unreachable = cfg - .predecessors(block_id) - .all(|block_id| unreachable_blocks.contains(&block_id)); + let has_predecessors = cfg.predecessors(block_id).len() > 0; + current_block_instructions_are_unreachable = has_predecessors + && cfg + .predecessors(block_id) + .all(|block_id| unreachable_blocks.contains(&block_id)); if current_block_instructions_are_unreachable { unreachable_blocks.insert(block_id); @@ -161,7 +164,9 @@ mod test { b0(): v0 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - return u1 0 + v3 = allocate -> &mut u1 + v4 = load v3 -> u1 + return v4 } "#); } @@ -186,7 +191,9 @@ mod test { b0(): v0 = make_array [] : [&mut u1; 0] constrain u1 0 != u1 0, "Index out of bounds" - return u1 0 + v2 = allocate -> &mut u1 + v3 = load v2 -> u1 + return v3 } "#); } @@ -217,11 +224,17 @@ mod test { b0(): v2 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - jmp b1(u1 0) + v5 = allocate -> &mut u1 + v6 = load v5 -> u1 + jmp b1(v6) b1(v0: u1): - jmp b2(u1 0) + v7 = allocate -> &mut u1 + v8 = load v7 -> u1 + jmp b2(v8) b2(v1: u1): - return u1 0 + v9 = allocate -> &mut u1 + v10 = load v9 -> u1 + return v10 } "#); } @@ -254,11 +267,17 @@ mod test { b0(): v2 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - jmp b2(u1 0) + v5 = allocate -> &mut u1 + v6 = load v5 -> u1 + jmp b2(v6) b1(v0: u1): - return u1 0 + v9 = allocate -> &mut u1 + v10 = load v9 -> u1 + return v10 b2(v1: u1): - jmp b1(u1 0) + v7 = allocate -> &mut u1 + v8 = load v7 -> u1 + jmp b1(v8) } "#); } @@ -329,7 +348,8 @@ mod test { b1(): jmp b2() b2(): - return Field 0 + v4 = add Field 1, Field 2 + return v4 } "#); } From 224f58f0cc284119b67552618c126b099c9d7183 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 24 Jun 2025 12:26:17 +0100 Subject: [PATCH 39/41] Need dominator tree for loops --- .../opt/remove_unreachable_instructions.rs | 64 +++++++++++++++---- 1 file changed, 50 insertions(+), 14 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index acbd31d6053..ba5394fd406 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -12,8 +12,9 @@ use noirc_errors::call_stack::CallStackId; use crate::ssa::{ ir::{ - basic_block::BasicBlockId, cfg::ControlFlowGraph, function::Function, - instruction::Instruction, post_order::PostOrder, types::Type, value::ValueId, + basic_block::BasicBlockId, cfg::ControlFlowGraph, dfg::DataFlowGraph, dom::DominatorTree, + function::Function, instruction::Instruction, post_order::PostOrder, types::Type, + value::ValueId, }, ssa_gen::Ssa, }; @@ -29,11 +30,12 @@ impl Ssa { impl Function { fn remove_unreachable_instructions(&mut self) { - println!("remove_unreachable_instructions from {}", self.id()); - // Iterate each block in reverse post order = forward order let cfg = ControlFlowGraph::with_function(self); - let mut block_order = PostOrder::with_cfg(&cfg).into_vec(); + let post_order = PostOrder::with_cfg(&cfg); + let mut dom = DominatorTree::with_cfg_and_post_order(&cfg, &post_order); + // Iterate each block in reverse post order = forward order // Start with the entry, process all blocks before their successors. + let mut block_order = post_order.into_vec(); block_order.reverse(); // The current block we are currently processing @@ -51,11 +53,12 @@ impl Function { if current_block_id != Some(block_id) { current_block_id = Some(block_id); - let has_predecessors = cfg.predecessors(block_id).len() > 0; - current_block_instructions_are_unreachable = has_predecessors - && cfg - .predecessors(block_id) - .all(|block_id| unreachable_blocks.contains(&block_id)); + + current_block_instructions_are_unreachable = unreachable_blocks.contains(&block_id) + || cfg.predecessors(block_id).len() > 0 + && cfg + .predecessors(block_id) + .all(|block_id| unreachable_blocks.contains(&block_id)); if current_block_instructions_are_unreachable { unreachable_blocks.insert(block_id); @@ -93,6 +96,7 @@ impl Function { if is_unreachable { unreachable_blocks.insert(block_id); current_block_instructions_are_unreachable = true; + add_dominated_blocks(block_id, context.dfg, &mut dom, &mut unreachable_blocks); } }); @@ -137,6 +141,33 @@ fn dummy_ref(function: &mut Function, block_id: BasicBlockId, typ: Type) -> Valu .first() } +/// Adds all of a block's dominated blocks to the `unreachable_blocks` set if they are dominated by that block. +fn add_dominated_blocks( + block_id: BasicBlockId, + dfg: &DataFlowGraph, + dom: &mut DominatorTree, + unreachable_blocks: &mut HashSet, +) { + // First compute the set of all blocks that are reachable from the starting block + let mut reachable_blocks = HashSet::default(); + + let mut blocks_to_process = vec![block_id]; + while let Some(block_id) = blocks_to_process.pop() { + for successor in dfg[block_id].successors() { + if reachable_blocks.insert(successor) { + blocks_to_process.push(successor); + } + } + } + + // Now add them to `unreachable_blocks` if they are dominated by the block + for reachable_block in reachable_blocks { + if dom.dominates(block_id, reachable_block) { + unreachable_blocks.insert(reachable_block); + } + } +} + #[cfg(test)] mod test { use crate::{ @@ -312,11 +343,15 @@ mod test { constrain u1 0 == u1 1, "Index out of bounds" jmp b1() b1(): - jmpif u1 0 then: b2, else: b3 + v2 = allocate -> &mut u1 + v3 = load v2 -> u1 + jmpif v3 then: b2, else: b3 b2(): jmp b1() b3(): - return Field 0 + v4 = allocate -> &mut Field + v5 = load v4 -> Field + return v5 } "#); } @@ -348,8 +383,9 @@ mod test { b1(): jmp b2() b2(): - v4 = add Field 1, Field 2 - return v4 + v2 = allocate -> &mut Field + v3 = load v2 -> Field + return v3 } "#); } From e141268dbc001376dea084c451c689dbf5f4264b Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 24 Jun 2025 13:21:38 +0100 Subject: [PATCH 40/41] Need zeroing as well --- compiler/noirc_evaluator/src/ssa.rs | 15 +- .../opt/remove_unreachable_instructions.rs | 193 +++++++++++++----- .../execute__tests__expanded.snap | 2 +- ...ig_false_inliner_-9223372036854775808.snap | 2 +- ..._tests__force_brillig_false_inliner_0.snap | 2 +- ...lig_false_inliner_9223372036854775807.snap | 2 +- 6 files changed, 161 insertions(+), 55 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs index e1bcb34703e..80644a61bd9 100644 --- a/compiler/noirc_evaluator/src/ssa.rs +++ b/compiler/noirc_evaluator/src/ssa.rs @@ -138,7 +138,10 @@ pub struct ArtifactsAndWarnings(pub Artifacts, pub Vec); /// something we take can advantage of in the [secondary_passes]. pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { vec![ - SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), + SsaPass::new( + move |ssa| ssa.remove_unreachable_instructions(false), + "Remove Unreachable Instructions", + ), SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), SsaPass::new(Ssa::defunctionalize, "Defunctionalization"), SsaPass::new(Ssa::inline_simple_functions, "Inlining simple functions"), @@ -214,7 +217,10 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { SsaPass::new(Ssa::brillig_array_get_and_set, "Brillig Array Get and Set Optimizations"), // Perform another DIE pass to update the used globals after offsetting Brillig indexes. SsaPass::new(Ssa::dead_instruction_elimination, "Dead Instruction Elimination"), - SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), + SsaPass::new( + move |ssa| ssa.remove_unreachable_instructions(true), + "Remove Unreachable Instructions", + ), // A function can be potentially unreachable post-DIE if all calls to that function were removed, // or after the removal of unreachable instructions. SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), @@ -232,7 +238,10 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { pub fn secondary_passes(brillig: &Brillig) -> Vec { vec![ SsaPass::new(move |ssa| ssa.fold_constants_with_brillig(brillig), "Inlining Brillig Calls"), - SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), + SsaPass::new( + move |ssa| ssa.remove_unreachable_instructions(true), + "Remove Unreachable Instructions", + ), // It could happen that we inlined all calls to a given brillig function. // In that case it's unused so we can remove it. This is what we check next. SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index ba5394fd406..43e6f3bf5df 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -7,6 +7,7 @@ //! by that block. use std::sync::Arc; +use acvm::{AcirField, FieldElement}; use fxhash::FxHashSet as HashSet; use noirc_errors::call_stack::CallStackId; @@ -20,16 +21,21 @@ use crate::ssa::{ }; impl Ssa { - pub(crate) fn remove_unreachable_instructions(mut self) -> Ssa { + /// Remove instructions following an always-failing constraint. + /// + /// If this pass is to be followed by other passes that need the CFG intact, + /// then we need to avoid replacing values in `JmpIf` terminators with zeros. + /// However at the end, before ACIR generation, that is the way to go. + pub(crate) fn remove_unreachable_instructions(mut self, use_zero_in_terminator: bool) -> Ssa { for function in self.functions.values_mut() { - function.remove_unreachable_instructions(); + function.remove_unreachable_instructions(use_zero_in_terminator); } self } } impl Function { - fn remove_unreachable_instructions(&mut self) { + fn remove_unreachable_instructions(&mut self, use_zero_in_terminator: bool) { let cfg = ControlFlowGraph::with_function(self); let post_order = PostOrder::with_cfg(&cfg); let mut dom = DominatorTree::with_cfg_and_post_order(&cfg, &post_order); @@ -104,13 +110,59 @@ impl Function { let mut terminator = self.dfg[block_id].take_terminator(); terminator.map_values_mut(|value_id| { let typ = self.dfg.type_of_value(value_id); - dummy_ref(self, block_id, typ) + if use_zero_in_terminator { + zeroed_value(self, block_id, &typ) + } else { + dummy_ref(self, block_id, typ) + } }); self.dfg[block_id].set_terminator(terminator); } } } +fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> ValueId { + match typ { + Type::Numeric(numeric_type) => { + function.dfg.make_constant(FieldElement::zero(), *numeric_type) + } + Type::Array(element_types, len) => { + let mut array = im::Vector::new(); + for _ in 0..*len { + for typ in element_types.iter() { + array.push_back(zeroed_value(function, block_id, typ)); + } + } + let instruction = Instruction::MakeArray { elements: array, typ: typ.clone() }; + let stack = CallStackId::root(); + function.dfg.insert_instruction_and_results(instruction, block_id, None, stack).first() + } + Type::Slice(_) => { + let array = im::Vector::new(); + let instruction = Instruction::MakeArray { elements: array, typ: typ.clone() }; + let stack = CallStackId::root(); + function.dfg.insert_instruction_and_results(instruction, block_id, None, stack).first() + } + Type::Reference(element_type) => { + let instruction = Instruction::Allocate; + let reference_type = Type::Reference(Arc::new((**element_type).clone())); + function + .dfg + .insert_instruction_and_results( + instruction, + block_id, + Some(vec![reference_type]), + CallStackId::root(), + ) + .first() + } + Type::Function => { + // We can have the function return itself. It's fine because the terminator is unreachable anyway. + function.dfg.import_function(function.id()) + } + } +} + /// Pretend that we have a value for the terminator by allocating a reference and loading it. /// /// We will never store to this reference, so it would be an error to actually execute the instruction, @@ -188,16 +240,14 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(); + let ssa = ssa.remove_unreachable_instructions(true); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { b0(): v0 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - v3 = allocate -> &mut u1 - v4 = load v3 -> u1 - return v4 + return u1 0 } "#); } @@ -215,16 +265,14 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(); + let ssa = ssa.remove_unreachable_instructions(true); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { b0(): v0 = make_array [] : [&mut u1; 0] constrain u1 0 != u1 0, "Index out of bounds" - v2 = allocate -> &mut u1 - v3 = load v2 -> u1 - return v3 + return u1 0 } "#); } @@ -248,24 +296,18 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(); + let ssa = ssa.remove_unreachable_instructions(true); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { b0(): v2 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - v5 = allocate -> &mut u1 - v6 = load v5 -> u1 - jmp b1(v6) + jmp b1(u1 0) b1(v0: u1): - v7 = allocate -> &mut u1 - v8 = load v7 -> u1 - jmp b2(v8) + jmp b2(u1 0) b2(v1: u1): - v9 = allocate -> &mut u1 - v10 = load v9 -> u1 - return v10 + return u1 0 } "#); } @@ -291,24 +333,18 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(); + let ssa = ssa.remove_unreachable_instructions(true); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { b0(): v2 = make_array [] : [&mut u1; 0] constrain u1 0 == u1 1, "Index out of bounds" - v5 = allocate -> &mut u1 - v6 = load v5 -> u1 - jmp b2(v6) + jmp b2(u1 0) b1(v0: u1): - v9 = allocate -> &mut u1 - v10 = load v9 -> u1 - return v10 + return u1 0 b2(v1: u1): - v7 = allocate -> &mut u1 - v8 = load v7 -> u1 - jmp b1(v8) + jmp b1(u1 0) } "#); } @@ -335,7 +371,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(); + let ssa = ssa.remove_unreachable_instructions(true); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { @@ -343,15 +379,11 @@ mod test { constrain u1 0 == u1 1, "Index out of bounds" jmp b1() b1(): - v2 = allocate -> &mut u1 - v3 = load v2 -> u1 - jmpif v3 then: b2, else: b3 + jmpif u1 0 then: b2, else: b3 b2(): jmp b1() b3(): - v4 = allocate -> &mut Field - v5 = load v4 -> Field - return v5 + return Field 0 } "#); } @@ -373,7 +405,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(); + let ssa = ssa.remove_unreachable_instructions(true); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { @@ -383,9 +415,7 @@ mod test { b1(): jmp b2() b2(): - v2 = allocate -> &mut Field - v3 = load v2 -> Field - return v3 + return Field 0 } "#); } @@ -411,7 +441,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(); + let ssa = ssa.remove_unreachable_instructions(true); assert_normalized_ssa_equals(ssa, src); } @@ -433,7 +463,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(); + let ssa = ssa.remove_unreachable_instructions(true); assert_normalized_ssa_equals(ssa, src); } @@ -457,7 +487,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(); + let ssa = ssa.remove_unreachable_instructions(true); assert_normalized_ssa_equals(ssa, src); } @@ -484,7 +514,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(); + let ssa = ssa.remove_unreachable_instructions(true); assert_normalized_ssa_equals(ssa, src); } @@ -510,7 +540,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(); + let ssa = ssa.remove_unreachable_instructions(true); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { @@ -529,4 +559,71 @@ mod test { } "#); } + + #[test] + fn can_use_dummy_refs_in_terminator_instead_of_zero() { + // Check that we did not replace `jmpif v0` with `jmpif u1 0`, which could end up + // being simplified into an infinite loop. + let src = r#" + acir(inline) fn main f0 { + b0(): + call f1(u1 1) + return + } + brillig(inline) fn func_2 f1 { + b0(v0: u1): + jmp b1() + b1(): + jmpif v0 then: b3, else: b4 + b2(): + return + b3(): + jmp b2() + b4(): + constrain u1 0 == u1 1 + jmp b5() + b5(): + jmpif v0 then: b7, else: b8 + b6(): + jmp b1() + b7(): + jmp b6() + b8(): + jmp b5() + } + "#; + let ssa = Ssa::from_str(src).unwrap(); + let ssa = ssa.remove_unreachable_instructions(false); + + assert_ssa_snapshot!(ssa, @r#" + acir(inline) fn main f0 { + b0(): + call f1(u1 1) + return + } + brillig(inline) fn func_2 f1 { + b0(v0: u1): + jmp b1() + b1(): + jmpif v0 then: b3, else: b4 + b2(): + return + b3(): + jmp b2() + b4(): + constrain u1 0 == u1 1 + jmp b5() + b5(): + v3 = allocate -> &mut u1 + v4 = load v3 -> u1 + jmpif v4 then: b7, else: b8 + b6(): + jmp b1() + b7(): + jmp b6() + b8(): + jmp b5() + } + "#); + } } diff --git a/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8774/execute__tests__expanded.snap b/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8774/execute__tests__expanded.snap index 5ad25880005..ad9077749d8 100644 --- a/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8774/execute__tests__expanded.snap +++ b/tooling/nargo_cli/tests/snapshots/compile_success_with_bug/regression_8774/execute__tests__expanded.snap @@ -4,5 +4,5 @@ expression: expanded_code --- fn main() -> pub bool { let d: [&mut bool; 0] = []; - *d[0] + *d[0_u32] } diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap index f03f0a18368..7fd1a21ecc9 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_-9223372036854775808.snap @@ -155,7 +155,7 @@ expression: artifact "unconstrained func 3", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLRWNZ2o8UuRR39Lp5Gh+uP+4Pp+/PPzff7l43D+fD8Xj4cX98ftxfDs+n+u/rZrBDqEe33QQHEYiHBEiEJEiGFIg2iaBEUCIoEZQISgQlghJBiaBEUBIoCZQESgIlgZJASaAkUBIoCZQMSgYlg5JByaBkUDIoGZQMSgalgFJAKaAUUAooBZQCSgGlgFJAUVAUFAVFQVFQFBQFRUFRUBQUNwxURxWqpwZqpCZqphYqeY48R54jz5HnyHPkOfIcea7yxFShMlArT97qj5ZZXyn1lVL/lVJuKqVMBaklllo9iDHogqAHgg4I2hc0L2hd0LigbQFFQBFQPCgeFA+KB8WD4kHxoHhQPCgelK+36tcSmF0CwiUgXALyVnO77873l/M4Wp7/tV3XTfxlfx5Pl8230/V43G5+7Y/XdtPPl/2p6WV/rleH7WY8PVWtwO+H42i/3rbv0cN0aFHHYBV/Cxf5aHwOmfG5DAviRRge5BYd/+29n472EhnuvVsSH7XHp7ggPgx96IObbD/NjF5/+pxv0cF/uHXxt8FLU62XlXM3Ey+pty95sn23NvnKquGb676GPvlDmey+/7y1o334dLL5meiYerROdn4m9dLQUz+5uAgQevdTWNYDLX36hsnF73RmBEIfghjjIkDpjxBVFkxB6A9Q95WpcHvBfVYC1e2ldyD6yQ6ElVNg79hVUzALWDkFdYe+DUGY7ED5vDmQoW9B4oYlD5DKLX56C3MrF/Is4CMLeRbwkSzyYWUWzQLWZlEabpMw/QR5SRbt6tn+8XD+9ztMLRdDMzb16Nsx1PZq/d6OqR1riZit1GybmBWYJgLxEKsurbyMOE2QDLFSNdAqRXqlSLOU6ZYy7VKmXyo0TIWOqdAkKV2S0iYpfZLSKCmdktIqKb2SwizJALfUVKHml5qSF8gL5JlnEpom6a4p0jZF+CYrgMwx2RvGLFNToXpqoEZqomaqcRKsk6l5p6aOSl4iL5FnBkoyHFTTzPvJMxMlChflB9iopmJ1K4xU00CNVsXCSzXNUPNPlvtmoJoK1VMDNVITNVOL1bkwUqbmpJo6KnlKnpJndson+KmmGf03R9XUeFa4/NqfD/uH42iJbal/PT32PK+nl98v/Ur/Ivlyfn4cn67n0dbE+2fJ2v5dHUifd8j6O1en10nZ9a9L7Yay9eX9hlBv0N3tG0H7syZPvbB7s7X3Bw==", + "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLheMf7UeKXIo7et08jQ/XH/eH0/fnn5tvd6+bh/PheDz8uD8+P+4vh+dT/fV1M1gTauu2m+AgAvGQAImQBMmQAtEmEZQISgQlghJBiaBEUCIoEZQISgIlgZJASaAkUBIoCZQESgIlgZJByaBkUDIoGZQMSgYlg5JByaAUUAooBZQCSgGlgFJAKaAUUAooCoqCoqAoKAqKgqKgKCgKioLihoHqqEL11ECN1ETN1EIlz5HnyHPkOfIceY48R54jz1WemCpUBmrlyVv90DLrK6W+Uuq/UspNpZSpILXEUqsHMQZDEIxAMABB/4LuBb0LOhf0LaAIKAKKB8WD4kHxoHhQPCgeFA+KB8WD8vVU/doCs1tAuAWEW0Deam730/n+ch5Hy/O/jut6iL/sz+Ppsvl2uh6P282v/fHaLvr5sj81vezP9d9huxlPT1Ur8PvhONqnt+179DAdWtQxWMXfwkU+Gp9DZnwuw4J4EYYHuUXHf0fvp6O9RIZ775bER+3xKS6ID0Of+uAm+08zs9fvPudbdPAf7l38bfLSVO9l5drNxEvq/Uue7N+tTb6yavrmhq+hL/5QJofvP2/vaJ8+nex+JjqmHq2Tg59JvTT01E8uLgKEPvwUlo1AS1++YXLzO52ZgdCnIMa4CFD6LUSVBUsQ+g3Uc2Uq3B5wn5VA9XjpA4h+cgBh5RLYM3bVEswCVi5BPaFvUxAmB1A+bw1k6EeQuGHJDaRyi58+wtzKjTwL+MhGngV8JIt8WJlFs4C1WZSG2yJM30FekkW7+m3/eDj/+x6mlouhGZva+taG2l+t31ubWltLxNpjaQWEttaqzWLVI0QgHmKVppWaEV8TJEOsbA20TZG+KdI4ZTqnTOuU6Z0KzVOheyo0TErHpLRMSs+kNE1K16S0TUrfpDBOMsA5NVWoeaem5AXyAnnmn4QGSrqDirRQER7KiiFzT/a0MfvUVKieGqiRmqiZapwEG2VqPqqpo5KXyEvkmZmSDDfVNPN68sxQicJR+QGWqqlYDQtT1TRQo1W08FVNM9S8lO0DM1NNheqpgRqpiZqpxWpemCpTc1VNHZU8JU/JM2vlE7xV04zxm7tqajwrYn7tz4f9w3G0JLdtcD099pyvXy+/X/o//e3ky/n5cXy6nkfbH++vKGv/d3Uifd4h6+9cXV4nZdffNLULytaX9wtCvUB3t/cF7ceaPPWP3Zvtwz8=", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_0.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_0.snap index f03f0a18368..7fd1a21ecc9 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_0.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_0.snap @@ -155,7 +155,7 @@ expression: artifact "unconstrained func 3", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLRWNZ2o8UuRR39Lp5Gh+uP+4Pp+/PPzff7l43D+fD8Xj4cX98ftxfDs+n+u/rZrBDqEe33QQHEYiHBEiEJEiGFIg2iaBEUCIoEZQISgQlghJBiaBEUBIoCZQESgIlgZJASaAkUBIoCZQMSgYlg5JByaBkUDIoGZQMSgalgFJAKaAUUAooBZQCSgGlgFJAUVAUFAVFQVFQFBQFRUFRUBQUNwxURxWqpwZqpCZqphYqeY48R54jz5HnyHPkOfIcea7yxFShMlArT97qj5ZZXyn1lVL/lVJuKqVMBaklllo9iDHogqAHgg4I2hc0L2hd0LigbQFFQBFQPCgeFA+KB8WD4kHxoHhQPCgelK+36tcSmF0CwiUgXALyVnO77873l/M4Wp7/tV3XTfxlfx5Pl8230/V43G5+7Y/XdtPPl/2p6WV/rleH7WY8PVWtwO+H42i/3rbv0cN0aFHHYBV/Cxf5aHwOmfG5DAviRRge5BYd/+29n472EhnuvVsSH7XHp7ggPgx96IObbD/NjF5/+pxv0cF/uHXxt8FLU62XlXM3Ey+pty95sn23NvnKquGb676GPvlDmey+/7y1o334dLL5meiYerROdn4m9dLQUz+5uAgQevdTWNYDLX36hsnF73RmBEIfghjjIkDpjxBVFkxB6A9Q95WpcHvBfVYC1e2ldyD6yQ6ElVNg79hVUzALWDkFdYe+DUGY7ED5vDmQoW9B4oYlD5DKLX56C3MrF/Is4CMLeRbwkSzyYWUWzQLWZlEabpMw/QR5SRbt6tn+8XD+9ztMLRdDMzb16Nsx1PZq/d6OqR1riZit1GybmBWYJgLxEKsurbyMOE2QDLFSNdAqRXqlSLOU6ZYy7VKmXyo0TIWOqdAkKV2S0iYpfZLSKCmdktIqKb2SwizJALfUVKHml5qSF8gL5JlnEpom6a4p0jZF+CYrgMwx2RvGLFNToXpqoEZqomaqcRKsk6l5p6aOSl4iL5FnBkoyHFTTzPvJMxMlChflB9iopmJ1K4xU00CNVsXCSzXNUPNPlvtmoJoK1VMDNVITNVOL1bkwUqbmpJo6KnlKnpJndson+KmmGf03R9XUeFa4/NqfD/uH42iJbal/PT32PK+nl98v/Ur/Ivlyfn4cn67n0dbE+2fJ2v5dHUifd8j6O1en10nZ9a9L7Yay9eX9hlBv0N3tG0H7syZPvbB7s7X3Bw==", + "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLheMf7UeKXIo7et08jQ/XH/eH0/fnn5tvd6+bh/PheDz8uD8+P+4vh+dT/fV1M1gTauu2m+AgAvGQAImQBMmQAtEmEZQISgQlghJBiaBEUCIoEZQISgIlgZJASaAkUBIoCZQESgIlgZJByaBkUDIoGZQMSgYlg5JByaAUUAooBZQCSgGlgFJAKaAUUAooCoqCoqAoKAqKgqKgKCgKioLihoHqqEL11ECN1ETN1EIlz5HnyHPkOfIceY48R54jz1WemCpUBmrlyVv90DLrK6W+Uuq/UspNpZSpILXEUqsHMQZDEIxAMABB/4LuBb0LOhf0LaAIKAKKB8WD4kHxoHhQPCgeFA+KB8WD8vVU/doCs1tAuAWEW0Deam730/n+ch5Hy/O/jut6iL/sz+Ppsvl2uh6P282v/fHaLvr5sj81vezP9d9huxlPT1Ur8PvhONqnt+179DAdWtQxWMXfwkU+Gp9DZnwuw4J4EYYHuUXHf0fvp6O9RIZ775bER+3xKS6ID0Of+uAm+08zs9fvPudbdPAf7l38bfLSVO9l5drNxEvq/Uue7N+tTb6yavrmhq+hL/5QJofvP2/vaJ8+nex+JjqmHq2Tg59JvTT01E8uLgKEPvwUlo1AS1++YXLzO52ZgdCnIMa4CFD6LUSVBUsQ+g3Uc2Uq3B5wn5VA9XjpA4h+cgBh5RLYM3bVEswCVi5BPaFvUxAmB1A+bw1k6EeQuGHJDaRyi58+wtzKjTwL+MhGngV8JIt8WJlFs4C1WZSG2yJM30FekkW7+m3/eDj/+x6mlouhGZva+taG2l+t31ubWltLxNpjaQWEttaqzWLVI0QgHmKVppWaEV8TJEOsbA20TZG+KdI4ZTqnTOuU6Z0KzVOheyo0TErHpLRMSs+kNE1K16S0TUrfpDBOMsA5NVWoeaem5AXyAnnmn4QGSrqDirRQER7KiiFzT/a0MfvUVKieGqiRmqiZapwEG2VqPqqpo5KXyEvkmZmSDDfVNPN68sxQicJR+QGWqqlYDQtT1TRQo1W08FVNM9S8lO0DM1NNheqpgRqpiZqpxWpemCpTc1VNHZU8JU/JM2vlE7xV04zxm7tqajwrYn7tz4f9w3G0JLdtcD099pyvXy+/X/o//e3ky/n5cXy6nkfbH++vKGv/d3Uifd4h6+9cXV4nZdffNLULytaX9wtCvUB3t/cF7ceaPPWP3Zvtwz8=", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", diff --git a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_9223372036854775807.snap b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_9223372036854775807.snap index f03f0a18368..7fd1a21ecc9 100644 --- a/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_9223372036854775807.snap +++ b/tooling/nargo_cli/tests/snapshots/execution_success/lambda_from_dynamic_if/execute__tests__force_brillig_false_inliner_9223372036854775807.snap @@ -155,7 +155,7 @@ expression: artifact "unconstrained func 3", "[Const { destination: Direct(21), bit_size: Integer(U32), value: 1 }, Const { destination: Direct(20), bit_size: Integer(U32), value: 0 }, CalldataCopy { destination_address: Direct(0), size_address: Direct(21), offset_address: Direct(20) }, Const { destination: Direct(2), bit_size: Field, value: 0 }, BinaryFieldOp { destination: Direct(3), op: Equals, lhs: Direct(0), rhs: Direct(2) }, JumpIf { condition: Direct(3), location: 8 }, Const { destination: Direct(1), bit_size: Field, value: 1 }, BinaryFieldOp { destination: Direct(0), op: Div, lhs: Direct(1), rhs: Direct(0) }, Stop { return_data: HeapVector { pointer: Direct(20), size: Direct(21) } }]" ], - "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLRWNZ2o8UuRR39Lp5Gh+uP+4Pp+/PPzff7l43D+fD8Xj4cX98ftxfDs+n+u/rZrBDqEe33QQHEYiHBEiEJEiGFIg2iaBEUCIoEZQISgQlghJBiaBEUBIoCZQESgIlgZJASaAkUBIoCZQMSgYlg5JByaBkUDIoGZQMSgalgFJAKaAUUAooBZQCSgGlgFJAUVAUFAVFQVFQFBQFRUFRUBQUNwxURxWqpwZqpCZqphYqeY48R54jz5HnyHPkOfIcea7yxFShMlArT97qj5ZZXyn1lVL/lVJuKqVMBaklllo9iDHogqAHgg4I2hc0L2hd0LigbQFFQBFQPCgeFA+KB8WD4kHxoHhQPCgelK+36tcSmF0CwiUgXALyVnO77873l/M4Wp7/tV3XTfxlfx5Pl8230/V43G5+7Y/XdtPPl/2p6WV/rleH7WY8PVWtwO+H42i/3rbv0cN0aFHHYBV/Cxf5aHwOmfG5DAviRRge5BYd/+29n472EhnuvVsSH7XHp7ggPgx96IObbD/NjF5/+pxv0cF/uHXxt8FLU62XlXM3Ey+pty95sn23NvnKquGb676GPvlDmey+/7y1o334dLL5meiYerROdn4m9dLQUz+5uAgQevdTWNYDLX36hsnF73RmBEIfghjjIkDpjxBVFkxB6A9Q95WpcHvBfVYC1e2ldyD6yQ6ElVNg79hVUzALWDkFdYe+DUGY7ED5vDmQoW9B4oYlD5DKLX56C3MrF/Is4CMLeRbwkSzyYWUWzQLWZlEabpMw/QR5SRbt6tn+8XD+9ztMLRdDMzb16Nsx1PZq/d6OqR1riZit1GybmBWYJgLxEKsurbyMOE2QDLFSNdAqRXqlSLOU6ZYy7VKmXyo0TIWOqdAkKV2S0iYpfZLSKCmdktIqKb2SwizJALfUVKHml5qSF8gL5JlnEpom6a4p0jZF+CYrgMwx2RvGLFNToXpqoEZqomaqcRKsk6l5p6aOSl4iL5FnBkoyHFTTzPvJMxMlChflB9iopmJ1K4xU00CNVsXCSzXNUPNPlvtmoJoK1VMDNVITNVOL1bkwUqbmpJo6KnlKnpJndson+KmmGf03R9XUeFa4/NqfD/uH42iJbal/PT32PK+nl98v/Ur/Ivlyfn4cn67n0dbE+2fJ2v5dHUifd8j6O1en10nZ9a9L7Yay9eX9hlBv0N3tG0H7syZPvbB7s7X3Bw==", + "debug_symbols": "7ZjNbtswEITfxWcfxOXv9lUCI3AStTBgOIFrFyiCvHu5nKHTHiSkEnLLheMf7UeKXIo7et08jQ/XH/eH0/fnn5tvd6+bh/PheDz8uD8+P+4vh+dT/fV1M1gTauu2m+AgAvGQAImQBMmQAtEmEZQISgQlghJBiaBEUCIoEZQISgIlgZJASaAkUBIoCZQESgIlgZJByaBkUDIoGZQMSgYlg5JByaAUUAooBZQCSgGlgFJAKaAUUAooCoqCoqAoKAqKgqKgKCgKioLihoHqqEL11ECN1ETN1EIlz5HnyHPkOfIceY48R54jz1WemCpUBmrlyVv90DLrK6W+Uuq/UspNpZSpILXEUqsHMQZDEIxAMABB/4LuBb0LOhf0LaAIKAKKB8WD4kHxoHhQPCgeFA+KB8WD8vVU/doCs1tAuAWEW0Deam730/n+ch5Hy/O/jut6iL/sz+Ppsvl2uh6P282v/fHaLvr5sj81vezP9d9huxlPT1Ur8PvhONqnt+179DAdWtQxWMXfwkU+Gp9DZnwuw4J4EYYHuUXHf0fvp6O9RIZ775bER+3xKS6ID0Of+uAm+08zs9fvPudbdPAf7l38bfLSVO9l5drNxEvq/Uue7N+tTb6yavrmhq+hL/5QJofvP2/vaJ8+nex+JjqmHq2Tg59JvTT01E8uLgKEPvwUlo1AS1++YXLzO52ZgdCnIMa4CFD6LUSVBUsQ+g3Uc2Uq3B5wn5VA9XjpA4h+cgBh5RLYM3bVEswCVi5BPaFvUxAmB1A+bw1k6EeQuGHJDaRyi58+wtzKjTwL+MhGngV8JIt8WJlFs4C1WZSG2yJM30FekkW7+m3/eDj/+x6mlouhGZva+taG2l+t31ubWltLxNpjaQWEttaqzWLVI0QgHmKVppWaEV8TJEOsbA20TZG+KdI4ZTqnTOuU6Z0KzVOheyo0TErHpLRMSs+kNE1K16S0TUrfpDBOMsA5NVWoeaem5AXyAnnmn4QGSrqDirRQER7KiiFzT/a0MfvUVKieGqiRmqiZapwEG2VqPqqpo5KXyEvkmZmSDDfVNPN68sxQicJR+QGWqqlYDQtT1TRQo1W08FVNM9S8lO0DM1NNheqpgRqpiZqpxWpemCpTc1VNHZU8JU/JM2vlE7xV04zxm7tqajwrYn7tz4f9w3G0JLdtcD099pyvXy+/X/o//e3ky/n5cXy6nkfbH++vKGv/d3Uifd4h6+9cXV4nZdffNLULytaX9wtCvUB3t/cF7ceaPPWP3Zvtwz8=", "file_map": { "22": { "source": "pub mod hash;\npub mod aes128;\npub mod array;\npub mod slice;\npub mod ecdsa_secp256k1;\npub mod ecdsa_secp256r1;\npub mod embedded_curve_ops;\npub mod field;\npub mod collections;\npub mod compat;\npub mod convert;\npub mod option;\npub mod string;\npub mod test;\npub mod cmp;\npub mod ops;\npub mod default;\npub mod prelude;\npub mod runtime;\npub mod meta;\npub mod append;\npub mod mem;\npub mod panic;\npub mod hint;\n\nuse convert::AsPrimitive;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle(with_newline: bool, input: T) {}\n\nunconstrained fn print_unconstrained(with_newline: bool, input: T) {\n print_oracle(with_newline, input);\n}\n\npub fn println(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(true, input);\n }\n}\n\npub fn print(input: T) {\n // Safety: a print statement cannot be constrained\n unsafe {\n print_unconstrained(false, input);\n }\n}\n\npub fn verify_proof(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n) {\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, 0);\n}\n\npub fn verify_proof_with_type(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {\n if !crate::runtime::is_unconstrained() {\n crate::assert_constant(proof_type);\n }\n verify_proof_internal(verification_key, proof, public_inputs, key_hash, proof_type);\n}\n\n#[foreign(recursive_aggregation)]\nfn verify_proof_internal(\n verification_key: [Field; N],\n proof: [Field; M],\n public_inputs: [Field; K],\n key_hash: Field,\n proof_type: u32,\n) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time.\n// The message can be a string, a format string, or any value, as long as it is known at compile-time\n#[builtin(static_assert)]\npub fn static_assert(predicate: bool, message: T) {}\n\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_add(y)\")]\npub fn wrapping_add(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() + y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_sub(y)\")]\npub fn wrapping_sub(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n AsPrimitive::as_(x.as_() + 340282366920938463463374607431768211456 - y.as_())\n}\n#[deprecated(\"wrapping operations should be done with the Wrapping traits. E.g: x.wrapping_mul(y)\")]\npub fn wrapping_mul(x: T, y: T) -> T\nwhere\n T: AsPrimitive,\n Field: AsPrimitive,\n{\n AsPrimitive::as_(x.as_() * y.as_())\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\nmod tests {\n use super::ops::arith::WrappingMul;\n\n #[test(should_fail_with = \"custom message\")]\n fn test_static_assert_custom_message() {\n super::static_assert(1 == 2, \"custom message\");\n }\n\n #[test]\n fn test_wrapping_mul() {\n let zero: u128 = 0;\n let one: u128 = 1;\n let two_pow_64: u128 = 0x10000000000000000;\n let u128_max: u128 = 0xffffffffffffffffffffffffffffffff;\n\n // 1*0==0\n assert_eq(zero, zero.wrapping_mul(one));\n\n // 0*1==0\n assert_eq(zero, one.wrapping_mul(zero));\n\n // 1*1==1\n assert_eq(one, one.wrapping_mul(one));\n\n // 0 * ( 1 << 64 ) == 0\n assert_eq(zero, zero.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * 0 == 0\n assert_eq(zero, two_pow_64.wrapping_mul(zero));\n\n // 1 * ( 1 << 64 ) == 1 << 64\n assert_eq(two_pow_64, two_pow_64.wrapping_mul(one));\n\n // ( 1 << 64 ) * 1 == 1 << 64\n assert_eq(two_pow_64, one.wrapping_mul(two_pow_64));\n\n // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n assert_eq(zero, two_pow_64.wrapping_mul(two_pow_64));\n // -1 * -1 == 1\n assert_eq(one, u128_max.wrapping_mul(u128_max));\n }\n}\n", From 2c957c637827789e8c300d2389ff8589f0cb6ed2 Mon Sep 17 00:00:00 2001 From: Akosh Farkash Date: Tue, 24 Jun 2025 13:56:19 +0100 Subject: [PATCH 41/41] Preserve consts --- compiler/noirc_evaluator/src/ssa.rs | 15 +--- .../opt/remove_unreachable_instructions.rs | 68 +++++++++++-------- 2 files changed, 44 insertions(+), 39 deletions(-) diff --git a/compiler/noirc_evaluator/src/ssa.rs b/compiler/noirc_evaluator/src/ssa.rs index 80644a61bd9..e1bcb34703e 100644 --- a/compiler/noirc_evaluator/src/ssa.rs +++ b/compiler/noirc_evaluator/src/ssa.rs @@ -138,10 +138,7 @@ pub struct ArtifactsAndWarnings(pub Artifacts, pub Vec); /// something we take can advantage of in the [secondary_passes]. pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { vec![ - SsaPass::new( - move |ssa| ssa.remove_unreachable_instructions(false), - "Remove Unreachable Instructions", - ), + SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), SsaPass::new(Ssa::defunctionalize, "Defunctionalization"), SsaPass::new(Ssa::inline_simple_functions, "Inlining simple functions"), @@ -217,10 +214,7 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { SsaPass::new(Ssa::brillig_array_get_and_set, "Brillig Array Get and Set Optimizations"), // Perform another DIE pass to update the used globals after offsetting Brillig indexes. SsaPass::new(Ssa::dead_instruction_elimination, "Dead Instruction Elimination"), - SsaPass::new( - move |ssa| ssa.remove_unreachable_instructions(true), - "Remove Unreachable Instructions", - ), + SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), // A function can be potentially unreachable post-DIE if all calls to that function were removed, // or after the removal of unreachable instructions. SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), @@ -238,10 +232,7 @@ pub fn primary_passes(options: &SsaEvaluatorOptions) -> Vec { pub fn secondary_passes(brillig: &Brillig) -> Vec { vec![ SsaPass::new(move |ssa| ssa.fold_constants_with_brillig(brillig), "Inlining Brillig Calls"), - SsaPass::new( - move |ssa| ssa.remove_unreachable_instructions(true), - "Remove Unreachable Instructions", - ), + SsaPass::new(Ssa::remove_unreachable_instructions, "Remove Unreachable Instructions"), // It could happen that we inlined all calls to a given brillig function. // In that case it's unused so we can remove it. This is what we check next. SsaPass::new(Ssa::remove_unreachable_functions, "Removing Unreachable Functions"), diff --git a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs index 43e6f3bf5df..f56268539cd 100644 --- a/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs +++ b/compiler/noirc_evaluator/src/ssa/opt/remove_unreachable_instructions.rs @@ -13,29 +13,31 @@ use noirc_errors::call_stack::CallStackId; use crate::ssa::{ ir::{ - basic_block::BasicBlockId, cfg::ControlFlowGraph, dfg::DataFlowGraph, dom::DominatorTree, - function::Function, instruction::Instruction, post_order::PostOrder, types::Type, - value::ValueId, + basic_block::BasicBlockId, + cfg::ControlFlowGraph, + dfg::DataFlowGraph, + dom::DominatorTree, + function::Function, + instruction::{Instruction, TerminatorInstruction}, + post_order::PostOrder, + types::Type, + value::{Value, ValueId}, }, ssa_gen::Ssa, }; impl Ssa { /// Remove instructions following an always-failing constraint. - /// - /// If this pass is to be followed by other passes that need the CFG intact, - /// then we need to avoid replacing values in `JmpIf` terminators with zeros. - /// However at the end, before ACIR generation, that is the way to go. - pub(crate) fn remove_unreachable_instructions(mut self, use_zero_in_terminator: bool) -> Ssa { + pub(crate) fn remove_unreachable_instructions(mut self) -> Ssa { for function in self.functions.values_mut() { - function.remove_unreachable_instructions(use_zero_in_terminator); + function.remove_unreachable_instructions(); } self } } impl Function { - fn remove_unreachable_instructions(&mut self, use_zero_in_terminator: bool) { + fn remove_unreachable_instructions(&mut self) { let cfg = ControlFlowGraph::with_function(self); let post_order = PostOrder::with_cfg(&cfg); let mut dom = DominatorTree::with_cfg_and_post_order(&cfg, &post_order); @@ -108,12 +110,20 @@ impl Function { for block_id in unreachable_blocks { let mut terminator = self.dfg[block_id].take_terminator(); + let use_dummy_ref = matches!(terminator, TerminatorInstruction::JmpIf { .. }); terminator.map_values_mut(|value_id| { - let typ = self.dfg.type_of_value(value_id); - if use_zero_in_terminator { - zeroed_value(self, block_id, &typ) + // We only need to replace values that come from instructions we may not have seen. + // Constant values, or values coming from parameters, can be preserved, and in some + // cases have to be, for example for loop boundaries that unrolling expects to be constant. + if matches!(self.dfg[value_id], Value::Instruction { .. }) { + let typ = self.dfg.type_of_value(value_id); + if use_dummy_ref { + dummy_ref(self, block_id, typ) + } else { + zeroed_value(self, block_id, &typ) + } } else { - dummy_ref(self, block_id, typ) + value_id } }); self.dfg[block_id].set_terminator(terminator); @@ -171,6 +181,10 @@ fn zeroed_value(function: &mut Function, block_id: BasicBlockId, typ: &Type) -> /// such as infinite loops, that other passes would have difficulty dealing with. /// /// The alternative to this is to have a new kind of _unreachable_ terminator instruction. +/// +/// Leaving dummy refs in the final SSA might cause errors in ACIR gen. If that happens, +/// then we need to give a hint that the pass isn't followed by anything that relies on +/// the CFG having any particular shape, and zeros can be used. fn dummy_ref(function: &mut Function, block_id: BasicBlockId, typ: Type) -> ValueId { // Pretend that we have a reference for the appropriate type. let instruction = Instruction::Allocate; @@ -240,7 +254,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(true); + let ssa = ssa.remove_unreachable_instructions(); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { @@ -265,7 +279,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(true); + let ssa = ssa.remove_unreachable_instructions(); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { @@ -296,7 +310,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(true); + let ssa = ssa.remove_unreachable_instructions(); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { @@ -333,7 +347,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(true); + let ssa = ssa.remove_unreachable_instructions(); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { @@ -371,7 +385,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(true); + let ssa = ssa.remove_unreachable_instructions(); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { @@ -405,7 +419,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(true); + let ssa = ssa.remove_unreachable_instructions(); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { @@ -441,7 +455,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(true); + let ssa = ssa.remove_unreachable_instructions(); assert_normalized_ssa_equals(ssa, src); } @@ -463,7 +477,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(true); + let ssa = ssa.remove_unreachable_instructions(); assert_normalized_ssa_equals(ssa, src); } @@ -487,7 +501,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(true); + let ssa = ssa.remove_unreachable_instructions(); assert_normalized_ssa_equals(ssa, src); } @@ -514,7 +528,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(true); + let ssa = ssa.remove_unreachable_instructions(); assert_normalized_ssa_equals(ssa, src); } @@ -540,7 +554,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(true); + let ssa = ssa.remove_unreachable_instructions(); assert_ssa_snapshot!(ssa, @r#" acir(inline) predicate_pure fn main f0 { @@ -561,7 +575,7 @@ mod test { } #[test] - fn can_use_dummy_refs_in_terminator_instead_of_zero() { + fn uses_dummy_refs_in_terminator_instead_of_zero_with_jmpif() { // Check that we did not replace `jmpif v0` with `jmpif u1 0`, which could end up // being simplified into an infinite loop. let src = r#" @@ -593,7 +607,7 @@ mod test { } "#; let ssa = Ssa::from_str(src).unwrap(); - let ssa = ssa.remove_unreachable_instructions(false); + let ssa = ssa.remove_unreachable_instructions(); assert_ssa_snapshot!(ssa, @r#" acir(inline) fn main f0 {